maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/mlir/test/IR/affine-map.mlir

348 lines
13 KiB
MLIR
Raw Normal View History

Implement support for constant folding operations and a simple constant folding optimization pass: - Give the ability for operations to implement a constantFold hook (a simple one for single-result ops as well as general support for multi-result ops). - Implement folding support for constant and addf. - Implement support in AbstractOperation and Operation to make this usable by clients. - Implement a very simple constant folding pass that does top down folding on CFG and ML functions, with a testcase that exercises all the above stuff. Random cleanups: - Improve the build APIs for ConstantOp. - Stop passing "-o -" to mlir-opt in the testsuite, since that is the default. PiperOrigin-RevId: 213749809
2018-09-20 12:35:11 +08:00
// RUN: mlir-opt %s | FileCheck %s
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
[mlir] Fix a use-after-free iterator error found by asan While fixing this the parser-affine-map.mlir test started failing due to ordering of the printed affine maps. Even the existing CHECK-DAGs weren't enough to disambiguate; a partial match on one line precluded a total match on a following line. The fix for this was easy - print the affine maps in reference order rather than in DenseMap iteration order. PiperOrigin-RevId: 205843770
2018-07-25 00:48:31 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d0, d1)
Adds ModuleState to support printing outlined AffineMaps. PiperOrigin-RevId: 204999887
2018-07-18 07:56:54 +08:00
#map0 = (i, j) -> (i, j)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0, d1)
#map1 = (i, j)[s0] -> (i, j)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
[mlir] Fix a use-after-free iterator error found by asan While fixing this the parser-affine-map.mlir test started failing due to ordering of the printed affine maps. Even the existing CHECK-DAGs weren't enough to disambiguate; a partial match on one line precluded a total match on a following line. The fix for this was easy - print the affine maps in reference order rather than in DenseMap iteration order. PiperOrigin-RevId: 205843770
2018-07-25 00:48:31 +08:00
// CHECK: #map{{[0-9]+}} = () -> (0)
Fix confusing CHECK-EMPTY in affine-map test This commit replaces // CHECK-EMPTY because it is an extremely confusing way of allowing (but not checking for) empty lines. The problem is that // CHECK-EMPTY is **only a comment** and does not do anything. I originally tried to use // CHECK-EMPTY: but errors occured due to missing newlines. The intended behavior of the test is to enforce nothing (not even a newline) is printed and the proper way to check for this is to use CHECK-NOT. Thanks to @rxwei for helping me figure out to use CHECK-NOT properly. PiperOrigin-RevId: 210286262
2018-08-27 01:56:24 +08:00
// A map may have 0 inputs.
// However, an affine_apply always takes at least one input.
Adds ModuleState to support printing outlined AffineMaps. PiperOrigin-RevId: 204999887
2018-07-18 07:56:54 +08:00
#map2 = () -> (0)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Fix confusing CHECK-EMPTY in affine-map test This commit replaces // CHECK-EMPTY because it is an extremely confusing way of allowing (but not checking for) empty lines. The problem is that // CHECK-EMPTY is **only a comment** and does not do anything. I originally tried to use // CHECK-EMPTY: but errors occured due to missing newlines. The intended behavior of the test is to enforce nothing (not even a newline) is printed and the proper way to check for this is to use CHECK-NOT. Thanks to @rxwei for helping me figure out to use CHECK-NOT properly. PiperOrigin-RevId: 210286262
2018-08-27 01:56:24 +08:00
// All the maps in the following block are equivalent and are unique'd as one
// map. Therefore there should be only one output and we explicitly CHECK-NOT
// for the others.
More simplification for affine binary op expr's. - simplify operations with identity elements (multiply by 1, add with 0). - simplify successive add/mul: fold constants, propagate constants to the right. - simplify floordiv and ceildiv when divisors are constants, and the LHS is a multiply expression with RHS constant. - fix an affine expression printing bug on paren emission. - while on this, fix affine-map test cases file (memref's using layout maps that were duplicates of existing ones should be emitted pointing to the unique'd one). PiperOrigin-RevId: 207046738
2018-08-02 13:02:00 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d0 + 1, d1 * 4 + 2)
#map3 = (i, j) -> (i+1, 4*j + 2)
Fix confusing CHECK-EMPTY in affine-map test This commit replaces // CHECK-EMPTY because it is an extremely confusing way of allowing (but not checking for) empty lines. The problem is that // CHECK-EMPTY is **only a comment** and does not do anything. I originally tried to use // CHECK-EMPTY: but errors occured due to missing newlines. The intended behavior of the test is to enforce nothing (not even a newline) is printed and the proper way to check for this is to use CHECK-NOT. Thanks to @rxwei for helping me figure out to use CHECK-NOT properly. PiperOrigin-RevId: 210286262
2018-08-27 01:56:24 +08:00
// CHECK-NOT: #map3{{[a-z]}}
More simplification for affine binary op expr's. - simplify operations with identity elements (multiply by 1, add with 0). - simplify successive add/mul: fold constants, propagate constants to the right. - simplify floordiv and ceildiv when divisors are constants, and the LHS is a multiply expression with RHS constant. - fix an affine expression printing bug on paren emission. - while on this, fix affine-map test cases file (memref's using layout maps that were duplicates of existing ones should be emitted pointing to the unique'd one). PiperOrigin-RevId: 207046738
2018-08-02 13:02:00 +08:00
#map3a = (i, j) -> (1+i, 4*j + 2)
#map3b = (i, j) -> (2 + 3 - 2*2 + i, 4*j + 2)
#map3c = (i, j) -> (i +1 + 0, 4*j + 2)
#map3d = (i, j) -> (i + 3 + 2 - 4, 4*j + 2)
#map3e = (i, j) -> (1*i+3*2-2*2-1, 4*j + 2)
#map3f = (i, j) -> (i + 1, 4*j*1 + 2)
#map3g = (i, j) -> (i + 1, 2*2*j + 2)
#map3h = (i, j) -> (i + 1, 2*j*2 + 2)
#map3i = (i, j) -> (i + 1, j*2*2 + 2)
#map3j = (i, j) -> (i + 1, j*1*4 + 2)
#map3k = (i, j) -> (i + 1, j*4*1 + 2)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Affine expression analysis and simplification. Outside of IR/ - simplify a MutableAffineMap by flattening the affine expressions - add a simplify affine expression pass that uses this analysis - update the FlatAffineConstraints API (to be used in the next CL) In IR: - add isMultipleOf and getKnownGCD for AffineExpr, and make the in-IR simplication of simplifyMod simpler and more powerful. - rename the AffineExpr visitor methods to distinguish b/w visiting and walking, and to simplify API names based on context. The next CL will use some of these for the loop unrolling/unroll-jam to make the detection for the need of cleanup loop powerful/non-trivial. A future CL will finally move this simplification to FlatAffineConstraints to make it more powerful. For eg., currently, even if a mod expr appearing in a part of the expression tree can't be simplified, the whole thing won't be simplified. PiperOrigin-RevId: 211012256
2018-08-31 08:35:15 +08:00
// The following reduction should be unique'd out too but such expression
// simplification is not performed for IR parsing, but only through analyses
// and transforms.
Add 2 extra MLIR affine tests This commit adds 2 tests: 1. a negative test in which the simplification of expression does not seem satisfactory. This test should be updated once expression simplification works reasonably. 2. a positive test in which floordiv and ceildiv return the same result, properly enforced with CHECK-NOT PiperOrigin-RevId: 210286267
2018-08-27 01:56:40 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d1 - d0 + (d0 - d1 + 1) * 2 + d1 - 1, d1 + d1 + d1 + d1 + 2)
#map3l = (i, j) -> ((j - i) + 2*(i - j + 1) + j - 1 + 0, j + j + 1 + j + j + 1)
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d0 + 2, d1)
Unique AffineDimExpr, AffineSymbolExpr, AffineConstantExpr, and allocate these from the bump pointer allocator. - delete AffineExpr destructors. PiperOrigin-RevId: 205943807
2018-07-25 13:34:09 +08:00
#map4 = (i, j) -> (3+3-2*2+i, j)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + s0, d1)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map5 = (i, j)[s0] -> (i + s0, j)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + s0, d1 + 5)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map6 = (i, j)[s0] -> (i + s0, j + 5)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + d1 + s0, d1)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map7 = (i, j)[s0] -> (i + j + s0, j)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
More simplification for affine binary op expr's. - simplify operations with identity elements (multiply by 1, add with 0). - simplify successive add/mul: fold constants, propagate constants to the right. - simplify floordiv and ceildiv when divisors are constants, and the LHS is a multiply expression with RHS constant. - fix an affine expression printing bug on paren emission. - while on this, fix affine-map test cases file (memref's using layout maps that were duplicates of existing ones should be emitted pointing to the unique'd one). PiperOrigin-RevId: 207046738
2018-08-02 13:02:00 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + d1 + s0 + 5, d1)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map8 = (i, j)[s0] -> (5 + i + j + s0, j)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + d1 + 5, d1)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map9 = (i, j)[s0] -> ((i + j) + 5, j)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + d1 + 5, d1)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map10 = (i, j)[s0] -> (i + (j + 5), j)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 * 2, d1 * 3)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map11 = (i, j)[s0] -> (2*i, 3*j)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
More simplification for affine binary op expr's. - simplify operations with identity elements (multiply by 1, add with 0). - simplify successive add/mul: fold constants, propagate constants to the right. - simplify floordiv and ceildiv when divisors are constants, and the LHS is a multiply expression with RHS constant. - fix an affine expression printing bug on paren emission. - while on this, fix affine-map test cases file (memref's using layout maps that were duplicates of existing ones should be emitted pointing to the unique'd one). PiperOrigin-RevId: 207046738
2018-08-02 13:02:00 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + (d1 + s0 * 3) * 5 + 12, d1)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map12 = (i, j)[s0] -> (i + 2*6 + 5*(j+s0*3), j)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 * 5 + d1, d1)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map13 = (i, j)[s0] -> (5*i + j, j)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + d1, d1)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map14 = (i, j)[s0] -> ((i + j), (j))
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
More simplification for affine binary op expr's. - simplify operations with identity elements (multiply by 1, add with 0). - simplify successive add/mul: fold constants, propagate constants to the right. - simplify floordiv and ceildiv when divisors are constants, and the LHS is a multiply expression with RHS constant. - fix an affine expression printing bug on paren emission. - while on this, fix affine-map test cases file (memref's using layout maps that were duplicates of existing ones should be emitted pointing to the unique'd one). PiperOrigin-RevId: 207046738
2018-08-02 13:02:00 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + d1 + 7, d1 + 3)
#map15 = (i, j)[s0] -> ((i + j + 2) + 5, (j)+3)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0, 0)
#map16 = (i, j)[s1] -> (i, 0)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0, d1 * s0)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map17 = (i, j)[s0] -> (i, s0*j)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d0, d0 * 3 + d1)
Adds ModuleState to support printing outlined AffineMaps. PiperOrigin-RevId: 204999887
2018-07-18 07:56:54 +08:00
#map19 = (i, j) -> (i, 3*i + j)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d0, d0 + d1 * 3)
Adds ModuleState to support printing outlined AffineMaps. PiperOrigin-RevId: 204999887
2018-07-18 07:56:54 +08:00
#map20 = (i, j) -> (i, i + 3*j)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
More simplification for affine binary op expr's. - simplify operations with identity elements (multiply by 1, add with 0). - simplify successive add/mul: fold constants, propagate constants to the right. - simplify floordiv and ceildiv when divisors are constants, and the LHS is a multiply expression with RHS constant. - fix an affine expression printing bug on paren emission. - while on this, fix affine-map test cases file (memref's using layout maps that were duplicates of existing ones should be emitted pointing to the unique'd one). PiperOrigin-RevId: 207046738
2018-08-02 13:02:00 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0, d0 * ((s0 * s0) * 9) + 3)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map18 = (i, j)[N] -> (i, 2 + N*N*9*i + 1)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1) -> (1, d0 + d1 * 3 + 5)
Adds ModuleState to support printing outlined AffineMaps. PiperOrigin-RevId: 204999887
2018-07-18 07:56:54 +08:00
#map21 = (i, j) -> (1, i + 3*j + 5)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (s0 * 5, d0 + d1 * 3 + d0 * 5)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map22 = (i, j)[s0] -> (5*s0, i + 3*j + 5*i)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0 * (s0 * s1), d1)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map23 = (i, j)[s0, s1] -> (i*(s0*s1), j)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0, d1 mod 5)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map24 = (i, j)[s0, s1] -> (i, j mod 5)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0, d1 floordiv 5)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map25 = (i, j)[s0, s1] -> (i, j floordiv 5)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0, d1 ceildiv 5)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map26 = (i, j)[s0, s1] -> (i, j ceildiv 5)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0, d0 - d1 - 5)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map29 = (i, j)[s0, s1] -> (i, i - j - 5)
Parsing support for affine maps and affine expressions A recursive descent parser for affine maps/expressions with operator precedence and associativity. (While on this, sketch out uniqui'ing functionality for affine maps and affine binary op expressions (partly).) PiperOrigin-RevId: 203222063
2018-07-04 11:16:08 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0, d0 - d1 * s1 + 2)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map30 = (i, j)[M, N] -> (i, i - N*j + 2)
Complete affine expr parsing support - check for non-affine expressions - handle negative numbers and negation of id's, expressions - functions to check if a map is pure affine or semi-affine - simplify/clean up affine map parsing code - report more errors messages, more accurate error messages PiperOrigin-RevId: 203773633
2018-07-10 00:00:25 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0 * -5, d1 * -3, -2, (d0 + d1) * -1, s0 * -1)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map32 = (i, j)[s0, s1] -> (-5*i, -3*j, -2, -1*(i+j), -1*s0)
Complete affine expr parsing support - check for non-affine expressions - handle negative numbers and negation of id's, expressions - functions to check if a map is pure affine or semi-affine - simplify/clean up affine map parsing code - report more errors messages, more accurate error messages PiperOrigin-RevId: 203773633
2018-07-10 00:00:25 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1) -> (-4, d0 * -1)
Adds ModuleState to support printing outlined AffineMaps. PiperOrigin-RevId: 204999887
2018-07-18 07:56:54 +08:00
#map33 = (i, j) -> (-2+-5-(-3), -1*i)
Complete affine expr parsing support - check for non-affine expressions - handle negative numbers and negation of id's, expressions - functions to check if a map is pure affine or semi-affine - simplify/clean up affine map parsing code - report more errors messages, more accurate error messages PiperOrigin-RevId: 203773633
2018-07-10 00:00:25 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0, d1 floordiv s0, d1 mod s0)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map34 = (i, j)[s0, s1] -> (i, j floordiv s0, j mod s0)
Complete affine expr parsing support - check for non-affine expressions - handle negative numbers and negation of id's, expressions - functions to check if a map is pure affine or semi-affine - simplify/clean up affine map parsing code - report more errors messages, more accurate error messages PiperOrigin-RevId: 203773633
2018-07-10 00:00:25 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1, d2)[s0, s1, s2] -> ((d0 * s1) * s2 + d1 * s1 + d2)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map35 = (i, j, k)[s0, s1, s2] -> (i*s1*s2 + j*s1 + k)
Complete affine expr parsing support - check for non-affine expressions - handle negative numbers and negation of id's, expressions - functions to check if a map is pure affine or semi-affine - simplify/clean up affine map parsing code - report more errors messages, more accurate error messages PiperOrigin-RevId: 203773633
2018-07-10 00:00:25 +08:00
More simplification for affine binary op expr's. - simplify operations with identity elements (multiply by 1, add with 0). - simplify successive add/mul: fold constants, propagate constants to the right. - simplify floordiv and ceildiv when divisors are constants, and the LHS is a multiply expression with RHS constant. - fix an affine expression printing bug on paren emission. - while on this, fix affine-map test cases file (memref's using layout maps that were duplicates of existing ones should be emitted pointing to the unique'd one). PiperOrigin-RevId: 207046738
2018-08-02 13:02:00 +08:00
// Constant folding.
[mlir] Fix a use-after-free iterator error found by asan While fixing this the parser-affine-map.mlir test started failing due to ordering of the printed affine maps. Even the existing CHECK-DAGs weren't enough to disambiguate; a partial match on one line precluded a total match on a following line. The fix for this was easy - print the affine maps in reference order rather than in DenseMap iteration order. PiperOrigin-RevId: 205843770
2018-07-25 00:48:31 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1) -> (8, 4, 1, 3, 2, 4)
Adds ModuleState to support printing outlined AffineMaps. PiperOrigin-RevId: 204999887
2018-07-18 07:56:54 +08:00
#map36 = (i, j) -> (5+3, 2*2, 8-7, 100 floordiv 32, 5 mod 3, 10 ceildiv 3)
[mlir] Fix a use-after-free iterator error found by asan While fixing this the parser-affine-map.mlir test started failing due to ordering of the printed affine maps. Even the existing CHECK-DAGs weren't enough to disambiguate; a partial match on one line precluded a total match on a following line. The fix for this was easy - print the affine maps in reference order rather than in DenseMap iteration order. PiperOrigin-RevId: 205843770
2018-07-25 00:48:31 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1) -> (4, 11, 512, 15)
Adds ModuleState to support printing outlined AffineMaps. PiperOrigin-RevId: 204999887
2018-07-18 07:56:54 +08:00
#map37 = (i, j) -> (5 mod 3 + 2, 5*3 - 4, 128 * (500 ceildiv 128), 40 floordiv 7 * 3)
Implement some simple affine expr canonicalization/simplification. - fold constants when possible. - for a mul expression, canonicalize to always keep the LHS as the constant/symbolic term, and similarly, the RHS for an add expression to keep it closer to the mathematical form. (Eg: f(x) = 3*x + 5)); other similar simplifications; - verify binary op expressions at creation time. TODO: we can completely drop AffineSubExpr, and instead use add and mul by -1. This way something like x - 4 and -4 + x get canonicalized to x + -1 * 4 instead of being x - 4 and x + -4. (The other alternative if wanted to retain AffineSubExpr would be to simplify x + -1*y to x - y and x + <neg number> to x - <pos number>). PiperOrigin-RevId: 204240258
2018-07-12 12:19:31 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d0 * 2 + 1, d1 + 2)
Adds ModuleState to support printing outlined AffineMaps. PiperOrigin-RevId: 204999887
2018-07-18 07:56:54 +08:00
#map38 = (i, j) -> (1 + i*2, 2 + j)
Implement some simple affine expr canonicalization/simplification. - fold constants when possible. - for a mul expression, canonicalize to always keep the LHS as the constant/symbolic term, and similarly, the RHS for an add expression to keep it closer to the mathematical form. (Eg: f(x) = 3*x + 5)); other similar simplifications; - verify binary op expressions at creation time. TODO: we can completely drop AffineSubExpr, and instead use add and mul by -1. This way something like x - 4 and -4 + x get canonicalized to x + -1 * 4 instead of being x - 4 and x + -4. (The other alternative if wanted to retain AffineSubExpr would be to simplify x + -1*y to x - y and x + <neg number> to x - <pos number>). PiperOrigin-RevId: 204240258
2018-07-12 12:19:31 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0 * s0, d0 + s0, d0 + 2, d1 * 2, s1 * 2, s0 + 2)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map39 = (i, j)[M, N] -> (i*M, M + i, 2+i, j*2, N*2, 2 + M)
Parse affine map range sizes. PiperOrigin-RevId: 204240947
2018-07-12 12:31:07 +08:00
[mlir] Fix a use-after-free iterator error found by asan While fixing this the parser-affine-map.mlir test started failing due to ordering of the printed affine maps. Even the existing CHECK-DAGs weren't enough to disambiguate; a partial match on one line precluded a total match on a following line. The fix for this was easy - print the affine maps in reference order rather than in DenseMap iteration order. PiperOrigin-RevId: 205843770
2018-07-25 00:48:31 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d0, d1) size (10, 20)
Adds ModuleState to support printing outlined AffineMaps. PiperOrigin-RevId: 204999887
2018-07-18 07:56:54 +08:00
#map40 = (i, j) -> (i, j) size (10, 20)
Parse affine map range sizes. PiperOrigin-RevId: 204240947
2018-07-12 12:31:07 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0, d1) size (s0, s1 + 10)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map41 = (i, j)[N, M] -> (i, j) size (N, M+10)
Parse affine map range sizes. PiperOrigin-RevId: 204240947
2018-07-12 12:31:07 +08:00
More simplification for affine binary op expr's. - simplify operations with identity elements (multiply by 1, add with 0). - simplify successive add/mul: fold constants, propagate constants to the right. - simplify floordiv and ceildiv when divisors are constants, and the LHS is a multiply expression with RHS constant. - fix an affine expression printing bug on paren emission. - while on this, fix affine-map test cases file (memref's using layout maps that were duplicates of existing ones should be emitted pointing to the unique'd one). PiperOrigin-RevId: 207046738
2018-08-02 13:02:00 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0, d1) size (128, s0 * 2 + s1 + 5)
Change mlir-opt.cpp to take a list of passes to run, simplifying the driver code. Change printing of affine map's to not print a space between the dim and symbol list. PiperOrigin-RevId: 206505419
2018-07-30 05:13:03 +08:00
#map42 = (i, j)[N, M] -> (i, j) size (64 + 64, 5 + 2*N + M)
Adds ModuleState to support printing outlined AffineMaps. PiperOrigin-RevId: 204999887
2018-07-18 07:56:54 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> ((d0 * 5) floordiv 4, (d1 ceildiv 7) mod s0)
#map43 = (i, j) [s0] -> ( i * 5 floordiv 4, j ceildiv 7 mod s0)
More simplification for affine binary op expr's. - simplify operations with identity elements (multiply by 1, add with 0). - simplify successive add/mul: fold constants, propagate constants to the right. - simplify floordiv and ceildiv when divisors are constants, and the LHS is a multiply expression with RHS constant. - fix an affine expression printing bug on paren emission. - while on this, fix affine-map test cases file (memref's using layout maps that were duplicates of existing ones should be emitted pointing to the unique'd one). PiperOrigin-RevId: 207046738
2018-08-02 13:02:00 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d0 - d1 * 2, (d1 * 6) floordiv 4)
#map44 = (i, j) -> (i - 2*j, j * 6 floordiv 4)
// Simplifications
// CHECK: #map{{[0-9]+}} = (d0, d1, d2)[s0] -> (d0 + d1 + d2 + 1, d2 + d1, (d0 * s0) * 8)
#map45 = (i, j, k) [N] -> (1 + i + 3 + j - 3 + k, k + 5 + j - 5, 2*i*4*N)
Sketch out affine analysis structures: AffineValueMap, IntegerValueSet, FlatAffineConstraints, and MutableAffineMap. All four classes introduced reside in lib/Analysis and are not meant to be used in the IR (from lib/IR or lib/Parser/). They are all mutable, alloc'ed, dealloc'ed - although with their fields pointing to immutable affine expressions (AffineExpr *). While on this, update simplifyMod to fold mod to a zero when possible. PiperOrigin-RevId: 209618437
2018-08-22 01:32:24 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1, d2) -> (0, d1, d0 * 2, 0)
#map46 = (i, j, k) -> (i*0, 1*j, i * 128 floordiv 64, j * 0 floordiv 64)
Affine expression analysis and simplification. Outside of IR/ - simplify a MutableAffineMap by flattening the affine expressions - add a simplify affine expression pass that uses this analysis - update the FlatAffineConstraints API (to be used in the next CL) In IR: - add isMultipleOf and getKnownGCD for AffineExpr, and make the in-IR simplication of simplifyMod simpler and more powerful. - rename the AffineExpr visitor methods to distinguish b/w visiting and walking, and to simplify API names based on context. The next CL will use some of these for the loop unrolling/unroll-jam to make the detection for the need of cleanup loop powerful/non-trivial. A future CL will finally move this simplification to FlatAffineConstraints to make it more powerful. For eg., currently, even if a mod expr appearing in a part of the expression tree can't be simplified, the whole thing won't be simplified. PiperOrigin-RevId: 211012256
2018-08-31 08:35:15 +08:00
// CHECK: #map{{[0-9]+}} = (d0, d1, d2) -> (d0, d0 * 4, 0, 0, 0)
#map47 = (i, j, k) -> (i * 64 ceildiv 64, i * 512 ceildiv 128, 4 * j mod 4, 4*j*4 mod 8, k mod 1)
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
Affine expression analysis and simplification. Outside of IR/ - simplify a MutableAffineMap by flattening the affine expressions - add a simplify affine expression pass that uses this analysis - update the FlatAffineConstraints API (to be used in the next CL) In IR: - add isMultipleOf and getKnownGCD for AffineExpr, and make the in-IR simplication of simplifyMod simpler and more powerful. - rename the AffineExpr visitor methods to distinguish b/w visiting and walking, and to simplify API names based on context. The next CL will use some of these for the loop unrolling/unroll-jam to make the detection for the need of cleanup loop powerful/non-trivial. A future CL will finally move this simplification to FlatAffineConstraints to make it more powerful. For eg., currently, even if a mod expr appearing in a part of the expression tree can't be simplified, the whole thing won't be simplified. PiperOrigin-RevId: 211012256
2018-08-31 08:35:15 +08:00
// floordiv should resolve similarly to ceildiv and be unique'd out.
Add 2 extra MLIR affine tests This commit adds 2 tests: 1. a negative test in which the simplification of expression does not seem satisfactory. This test should be updated once expression simplification works reasonably. 2. a positive test in which floordiv and ceildiv return the same result, properly enforced with CHECK-NOT PiperOrigin-RevId: 210286267
2018-08-27 01:56:40 +08:00
// CHECK-NOT: #map48{{[a-z]}}
#map48 = (i, j, k) -> (i * 64 floordiv 64, i * 512 floordiv 128, 4 * j mod 4, 4*j*4 mod 8)
Affine expression analysis and simplification. Outside of IR/ - simplify a MutableAffineMap by flattening the affine expressions - add a simplify affine expression pass that uses this analysis - update the FlatAffineConstraints API (to be used in the next CL) In IR: - add isMultipleOf and getKnownGCD for AffineExpr, and make the in-IR simplication of simplifyMod simpler and more powerful. - rename the AffineExpr visitor methods to distinguish b/w visiting and walking, and to simplify API names based on context. The next CL will use some of these for the loop unrolling/unroll-jam to make the detection for the need of cleanup loop powerful/non-trivial. A future CL will finally move this simplification to FlatAffineConstraints to make it more powerful. For eg., currently, even if a mod expr appearing in a part of the expression tree can't be simplified, the whole thing won't be simplified. PiperOrigin-RevId: 211012256
2018-08-31 08:35:15 +08:00
// Simplifications for mod using known GCD's of the LHS expr.
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (0, 0, 0, (d0 * 4 + 3) mod 2)
#map49 = (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)
Extend getConstantTripCount to deal with a larger subset of loop bounds; make loop unroll/unroll-and-jam more powerful; add additional affine expr builder methods - use previously added analysis/simplification to infer multiple of unroll factor trip counts, making loop unroll/unroll-and-jam more general. - for loop unroll, support bounds that are single result affine map's with the same set of operands. For unknown loop bounds, loop unroll will now work as long as trip count can be determined to be a multiple of unroll factor. - extend getConstantTripCount to deal with single result affine map's with the same operands. move it to mlir/Analysis/LoopAnalysis.cpp - add additional builder utility methods for affine expr arithmetic (difference, mod/floordiv/ceildiv w.r.t postitive constant). simplify code to use the utility methods. - move affine analysis routines to AffineAnalysis.cpp/.h from AffineStructures.cpp/.h. - Rename LoopUnrollJam to LoopUnrollAndJam to match class name. - add an additional simplification for simplifyFloorDiv, simplifyCeilDiv - Rename AffineMap::getNumOperands() getNumInputs: an affine map by itself does not have operands. Operands are passed to it through affine_apply, from loop bounds/if condition's, etc., operands are stored in the latter. This should be sufficiently powerful for now as far as unroll/unroll-and-jam go for TPU code generation, and can move to other analyses/transformations. Loop nests like these are now unrolled without any cleanup loop being generated. for %i = 1 to 100 { // unroll factor 4: no cleanup loop will be generated. for %j = (d0) -> (d0) (%i) to (d0) -> (5*d0 + 3) (%i) { %x = "foo"(%j) : (affineint) -> i32 } } for %i = 1 to 100 { // unroll factor 4: no cleanup loop will be generated. for %j = (d0) -> (d0) (%i) to (d0) -> (d0 - d mod 4 - 1) (%i) { %y = "foo"(%j) : (affineint) -> i32 } } for %i = 1 to 100 { for %j = (d0) -> (d0) (%i) to (d0) -> (d0 + 128) (%i) { %x = "foo"() : () -> i32 } } TODO(bondhugula): extend this to LoopUnrollAndJam as well in the next CL (with minor changes). PiperOrigin-RevId: 212661212
2018-09-13 01:21:23 +08:00
// Floordiv, ceildiv divide by one.
// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 * 2 + 1, d1 + s0)
#map50 = (i, j)[s0] -> ( (i * 2 + 1) ceildiv 1, (j + s0) floordiv 1)
Fix MLIR's floordiv, ceildiv, and mod for constant inputs (for negative lhs's) - introduce mlir::{floorDiv, ceilDiv, mod} for constant inputs in mlir/Support/MathExtras.h - consistently use these everywhere in IR, Analysis, and Transforms. PiperOrigin-RevId: 215580677
2018-10-04 01:07:54 +08:00
// floordiv, ceildiv, and mod where LHS is negative.
// CHECK: #map{{[0-9]+}} = (d0) -> (-2, 1, -1)
#map51 = (i) -> (-5 floordiv 3, -5 mod 3, -5 ceildiv 3)
Adds ModuleState to support printing outlined AffineMaps. PiperOrigin-RevId: 204999887
2018-07-18 07:56:54 +08:00
// CHECK: extfunc @f0(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f0(memref<2x4xi8, #map0, 1>)
// CHECK: extfunc @f1(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f1(memref<2x4xi8, #map1, 1>)
// CHECK: extfunc @f2(memref<2xi8, #map{{[0-9]+}}, 1>)
extfunc @f2(memref<2xi8, #map2, 1>)
// CHECK: extfunc @f3(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f3(memref<2x4xi8, #map3, 1>)
More simplification for affine binary op expr's. - simplify operations with identity elements (multiply by 1, add with 0). - simplify successive add/mul: fold constants, propagate constants to the right. - simplify floordiv and ceildiv when divisors are constants, and the LHS is a multiply expression with RHS constant. - fix an affine expression printing bug on paren emission. - while on this, fix affine-map test cases file (memref's using layout maps that were duplicates of existing ones should be emitted pointing to the unique'd one). PiperOrigin-RevId: 207046738
2018-08-02 13:02:00 +08:00
// CHECK: extfunc @f3a(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f3a(memref<2x4xi8, #map3a, 1>)
// CHECK: extfunc @f3b(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f3b(memref<2x4xi8, #map3b, 1>)
// CHECK: extfunc @f3c(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f3c(memref<2x4xi8, #map3c, 1>)
// CHECK: extfunc @f3d(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f3d(memref<2x4xi8, #map3d, 1>)
// CHECK: extfunc @f3e(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f3e(memref<2x4xi8, #map3e, 1>)
// CHECK: extfunc @f3f(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f3f(memref<2x4xi8, #map3f, 1>)
// CHECK: extfunc @f3g(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f3g(memref<2x4xi8, #map3g, 1>)
// CHECK: extfunc @f3h(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f3h(memref<2x4xi8, #map3h, 1>)
// CHECK: extfunc @f3i(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f3i(memref<2x4xi8, #map3i, 1>)
// CHECK: extfunc @f3j(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f3j(memref<2x4xi8, #map3j, 1>)
// CHECK: extfunc @f3k(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f3k(memref<2x4xi8, #map3k, 1>)
Add 2 extra MLIR affine tests This commit adds 2 tests: 1. a negative test in which the simplification of expression does not seem satisfactory. This test should be updated once expression simplification works reasonably. 2. a positive test in which floordiv and ceildiv return the same result, properly enforced with CHECK-NOT PiperOrigin-RevId: 210286267
2018-08-27 01:56:40 +08:00
// CHECK: extfunc @f3l(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f3l(memref<2x4xi8, #map3l, 1>)
Adds ModuleState to support printing outlined AffineMaps. PiperOrigin-RevId: 204999887
2018-07-18 07:56:54 +08:00
// CHECK: extfunc @f4(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f4(memref<2x4xi8, #map4, 1>)
// CHECK: extfunc @f5(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f5(memref<2x4xi8, #map5, 1>)
// CHECK: extfunc @f6(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f6(memref<2x4xi8, #map6, 1>)
// CHECK: extfunc @f7(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f7(memref<2x4xi8, #map7, 1>)
// CHECK: extfunc @f8(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f8(memref<2x4xi8, #map8, 1>)
// CHECK: extfunc @f9(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f9(memref<2x4xi8, #map9, 1>)
// CHECK: extfunc @f10(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f10(memref<2x4xi8, #map10, 1>)
// CHECK: extfunc @f11(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f11(memref<2x4xi8, #map11, 1>)
// CHECK: extfunc @f12(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f12(memref<2x4xi8, #map12, 1>)
// CHECK: extfunc @f13(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f13(memref<2x4xi8, #map13, 1>)
// CHECK: extfunc @f14(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f14(memref<2x4xi8, #map14, 1>)
// CHECK: extfunc @f15(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f15(memref<2x4xi8, #map15, 1>)
// CHECK: extfunc @f16(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f16(memref<2x4xi8, #map16, 1>)
// CHECK: extfunc @f17(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f17(memref<2x4xi8, #map17, 1>)
// CHECK: extfunc @f19(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f19(memref<2x4xi8, #map19, 1>)
// CHECK: extfunc @f20(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f20(memref<2x4xi8, #map20, 1>)
// CHECK: extfunc @f18(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f18(memref<2x4xi8, #map18, 1>)
// CHECK: extfunc @f21(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f21(memref<2x4xi8, #map21, 1>)
// CHECK: extfunc @f22(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f22(memref<2x4xi8, #map22, 1>)
// CHECK: extfunc @f23(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f23(memref<2x4xi8, #map23, 1>)
// CHECK: extfunc @f24(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f24(memref<2x4xi8, #map24, 1>)
// CHECK: extfunc @f25(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f25(memref<2x4xi8, #map25, 1>)
// CHECK: extfunc @f26(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f26(memref<2x4xi8, #map26, 1>)
// CHECK: extfunc @f29(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f29(memref<2x4xi8, #map29, 1>)
// CHECK: extfunc @f30(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f30(memref<2x4xi8, #map30, 1>)
// CHECK: extfunc @f32(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f32(memref<2x4xi8, #map32, 1>)
// CHECK: extfunc @f33(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f33(memref<2x4xi8, #map33, 1>)
// CHECK: extfunc @f34(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f34(memref<2x4xi8, #map34, 1>)
// CHECK: extfunc @f35(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f35(memref<2x4xi8, #map35, 1>)
// CHECK: extfunc @f36(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f36(memref<2x4xi8, #map36, 1>)
// CHECK: extfunc @f37(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f37(memref<2x4xi8, #map37, 1>)
// CHECK: extfunc @f38(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f38(memref<2x4xi8, #map38, 1>)
// CHECK: extfunc @f39(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f39(memref<2x4xi8, #map39, 1>)
// CHECK: extfunc @f40(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f40(memref<2x4xi8, #map40, 1>)
// CHECK: extfunc @f41(memref<2x4xi8, #map{{[0-9]+}}, 1>)
extfunc @f41(memref<2x4xi8, #map41, 1>)
// CHECK: extfunc @f42(memref<2x4xi8, #map{{[0-9]+}}, 1>)
Simplify affine binary op expression class hierarchy - Drop sub-classing of affine binary op expressions. - Drop affine expr op kind sub. Represent it as multiply by -1 and add. This will also be in line with the math form when we'll need to represent a system of linear equalities/inequalities: the negative number goes into the coefficient of an affine form. (For eg. x_1 + (-1)*x_2 + 3*x_3 + (-2) >= 0). The folding simplification will transparently deal with multiplying the -1 with any other constants. This also means we won't need to simplify a multiply expression like in x_1 + (-2)*x_2 to a subtract expression (x_1 - 2*x_2) for canonicalization/uniquing. - When we print the IR, we will still pretty print to a subtract when possible. PiperOrigin-RevId: 205298958
2018-07-20 05:08:50 +08:00
extfunc @f42(memref<2x4xi8, #map42, 1>)
Fix FIXME's/TODOs: - Enhance memref type to allow omission of mappings and address spaces (implying a default mapping). - Fix printing of function types to properly recurse with printType so mappings are printed by name. - Simplify parsing of AffineMaps a bit now that we have isSymbolicOrConstant() PiperOrigin-RevId: 206039755
2018-07-26 03:55:50 +08:00
// CHECK: extfunc @f43(memref<2x4xi8, #map{{[0-9]+}}>)
More simplification for affine binary op expr's. - simplify operations with identity elements (multiply by 1, add with 0). - simplify successive add/mul: fold constants, propagate constants to the right. - simplify floordiv and ceildiv when divisors are constants, and the LHS is a multiply expression with RHS constant. - fix an affine expression printing bug on paren emission. - while on this, fix affine-map test cases file (memref's using layout maps that were duplicates of existing ones should be emitted pointing to the unique'd one). PiperOrigin-RevId: 207046738
2018-08-02 13:02:00 +08:00
extfunc @f43(memref<2x4xi8, #map43>)
Fix FIXME's/TODOs: - Enhance memref type to allow omission of mappings and address spaces (implying a default mapping). - Fix printing of function types to properly recurse with printType so mappings are printed by name. - Simplify parsing of AffineMaps a bit now that we have isSymbolicOrConstant() PiperOrigin-RevId: 206039755
2018-07-26 03:55:50 +08:00
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
// CHECK: extfunc @f44(memref<2x4xi8, #map{{[0-9]+}}>)
More simplification for affine binary op expr's. - simplify operations with identity elements (multiply by 1, add with 0). - simplify successive add/mul: fold constants, propagate constants to the right. - simplify floordiv and ceildiv when divisors are constants, and the LHS is a multiply expression with RHS constant. - fix an affine expression printing bug on paren emission. - while on this, fix affine-map test cases file (memref's using layout maps that were duplicates of existing ones should be emitted pointing to the unique'd one). PiperOrigin-RevId: 207046738
2018-08-02 13:02:00 +08:00
extfunc @f44(memref<2x4xi8, #map44>)
Revise the AffineExpr printing logic to be more careful about paren emission. This is still (intentionally) generating redundant parens for nested tightly binding expressions, but I think that is reasonable for readability sake. This also print x-y instead of x-(y*1) PiperOrigin-RevId: 206847212
2018-08-01 07:21:36 +08:00
More simplification for affine binary op expr's. - simplify operations with identity elements (multiply by 1, add with 0). - simplify successive add/mul: fold constants, propagate constants to the right. - simplify floordiv and ceildiv when divisors are constants, and the LHS is a multiply expression with RHS constant. - fix an affine expression printing bug on paren emission. - while on this, fix affine-map test cases file (memref's using layout maps that were duplicates of existing ones should be emitted pointing to the unique'd one). PiperOrigin-RevId: 207046738
2018-08-02 13:02:00 +08:00
// CHECK: extfunc @f45(memref<100x100x100xi8, #map{{[0-9]+}}>)
extfunc @f45(memref<100x100x100xi8, #map45>)
Fix FIXME's/TODOs: - Enhance memref type to allow omission of mappings and address spaces (implying a default mapping). - Fix printing of function types to properly recurse with printType so mappings are printed by name. - Simplify parsing of AffineMaps a bit now that we have isSymbolicOrConstant() PiperOrigin-RevId: 206039755
2018-07-26 03:55:50 +08:00
Implement a module-level symbol table for functions, enforcing uniqueness of names across the module and auto-renaming conflicts. Have the parser reject malformed modules that have redefinitions. PiperOrigin-RevId: 209227560
2018-08-18 07:49:42 +08:00
// CHECK: extfunc @f46(memref<100x100x100xi8, #map{{[0-9]+}}>)
extfunc @f46(memref<100x100x100xi8, #map46>)
Sketch out affine analysis structures: AffineValueMap, IntegerValueSet, FlatAffineConstraints, and MutableAffineMap. All four classes introduced reside in lib/Analysis and are not meant to be used in the IR (from lib/IR or lib/Parser/). They are all mutable, alloc'ed, dealloc'ed - although with their fields pointing to immutable affine expressions (AffineExpr *). While on this, update simplifyMod to fold mod to a zero when possible. PiperOrigin-RevId: 209618437
2018-08-22 01:32:24 +08:00
// CHECK: extfunc @f47(memref<100x100x100xi8, #map{{[0-9]+}}>)
extfunc @f47(memref<100x100x100xi8, #map47>)
Add 2 extra MLIR affine tests This commit adds 2 tests: 1. a negative test in which the simplification of expression does not seem satisfactory. This test should be updated once expression simplification works reasonably. 2. a positive test in which floordiv and ceildiv return the same result, properly enforced with CHECK-NOT PiperOrigin-RevId: 210286267
2018-08-27 01:56:40 +08:00
// CHECK: extfunc @f48(memref<100x100x100xi8, #map{{[0-9]+}}>)
extfunc @f48(memref<100x100x100xi8, #map48>)
Affine expression analysis and simplification. Outside of IR/ - simplify a MutableAffineMap by flattening the affine expressions - add a simplify affine expression pass that uses this analysis - update the FlatAffineConstraints API (to be used in the next CL) In IR: - add isMultipleOf and getKnownGCD for AffineExpr, and make the in-IR simplication of simplifyMod simpler and more powerful. - rename the AffineExpr visitor methods to distinguish b/w visiting and walking, and to simplify API names based on context. The next CL will use some of these for the loop unrolling/unroll-jam to make the detection for the need of cleanup loop powerful/non-trivial. A future CL will finally move this simplification to FlatAffineConstraints to make it more powerful. For eg., currently, even if a mod expr appearing in a part of the expression tree can't be simplified, the whole thing won't be simplified. PiperOrigin-RevId: 211012256
2018-08-31 08:35:15 +08:00
// CHECK: extfunc @f49(memref<100x100xi8, #map{{[0-9]+}}>)
extfunc @f49(memref<100x100xi8, #map49>)
Extend getConstantTripCount to deal with a larger subset of loop bounds; make loop unroll/unroll-and-jam more powerful; add additional affine expr builder methods - use previously added analysis/simplification to infer multiple of unroll factor trip counts, making loop unroll/unroll-and-jam more general. - for loop unroll, support bounds that are single result affine map's with the same set of operands. For unknown loop bounds, loop unroll will now work as long as trip count can be determined to be a multiple of unroll factor. - extend getConstantTripCount to deal with single result affine map's with the same operands. move it to mlir/Analysis/LoopAnalysis.cpp - add additional builder utility methods for affine expr arithmetic (difference, mod/floordiv/ceildiv w.r.t postitive constant). simplify code to use the utility methods. - move affine analysis routines to AffineAnalysis.cpp/.h from AffineStructures.cpp/.h. - Rename LoopUnrollJam to LoopUnrollAndJam to match class name. - add an additional simplification for simplifyFloorDiv, simplifyCeilDiv - Rename AffineMap::getNumOperands() getNumInputs: an affine map by itself does not have operands. Operands are passed to it through affine_apply, from loop bounds/if condition's, etc., operands are stored in the latter. This should be sufficiently powerful for now as far as unroll/unroll-and-jam go for TPU code generation, and can move to other analyses/transformations. Loop nests like these are now unrolled without any cleanup loop being generated. for %i = 1 to 100 { // unroll factor 4: no cleanup loop will be generated. for %j = (d0) -> (d0) (%i) to (d0) -> (5*d0 + 3) (%i) { %x = "foo"(%j) : (affineint) -> i32 } } for %i = 1 to 100 { // unroll factor 4: no cleanup loop will be generated. for %j = (d0) -> (d0) (%i) to (d0) -> (d0 - d mod 4 - 1) (%i) { %y = "foo"(%j) : (affineint) -> i32 } } for %i = 1 to 100 { for %j = (d0) -> (d0) (%i) to (d0) -> (d0 + 128) (%i) { %x = "foo"() : () -> i32 } } TODO(bondhugula): extend this to LoopUnrollAndJam as well in the next CL (with minor changes). PiperOrigin-RevId: 212661212
2018-09-13 01:21:23 +08:00
// CHECK: extfunc @f50(memref<100x100xi8, #map{{[0-9]+}}>)
extfunc @f50(memref<100x100xi8, #map50>)
Fix MLIR's floordiv, ceildiv, and mod for constant inputs (for negative lhs's) - introduce mlir::{floorDiv, ceilDiv, mod} for constant inputs in mlir/Support/MathExtras.h - consistently use these everywhere in IR, Analysis, and Transforms. PiperOrigin-RevId: 215580677
2018-10-04 01:07:54 +08:00
// CHECK: extfunc @f51(memref<1xi8, #map{{[0-9]+}}>)
extfunc @f51(memref<1xi8, #map51>)