This is an archive of the discontinued LLVM Phabricator instance.

Differential D98609

[Canonicalizer] Process regions top-down instead of bottom up & reuse existing constants.
ClosedPublic

Authored by lattner on Mar 14 2021, 1:15 PM.

Details

Reviewers
antiagainst
aartbik
rriddle
mravishankar
nicolasvasilache
Commits
rGb5d9a3c92358: [Canonicalizer] Process regions top-down instead of bottom up & reuse existing…
Summary

Two changes:

  1. Change the canonicalizer to walk the function in top-down order instead of bottom-up order. This composes well with the "top down" nature of constant folding and simplification, reducing iterations and re-evaluation of ops in simple cases.
  2. Explicitly enter existing constants into the OperationFolder table before canonicalizing. Previously we would "constant fold" them and rematerialize them, wastefully recreating a bunch fo constants, which lead to pointless memory traffic.

Both changes together provide a 33% speedup for canonicalize on some mid-size
CIRCT examples.

One artifact of this change is that the constants generated in normal pattern
application get inserted at the top of the function as the patterns are applied.
Because of this, we get "inverted" constants more often, which is an aethetic
change to the IR but does permute some testcases.

Diff Detail

Event Timeline

lattner created this revision.Mar 14 2021, 1:15 PM
Herald added a reviewer: mravishankar. · View Herald TranscriptMar 14 2021, 1:15 PM
Herald added a reviewer: antiagainst. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added subscribers: dcaballe, cota, mravishankar and 20 others. · View Herald Transcript
lattner requested review of this revision.Mar 14 2021, 1:15 PM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptMar 14 2021, 1:15 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
lattner edited reviewers, added: rriddle; removed: mravishankar, nicolasvasilache.Mar 14 2021, 1:16 PM
Herald added a reviewer: mravishankar. · View Herald TranscriptMar 14 2021, 1:16 PM
Herald added a reviewer: nicolasvasilache. · View Herald Transcript
lattner added a comment.Mar 14 2021, 1:19 PM

I'll also note that changing the order of visitation did also expose two "bugs", one is that vector.shape_cast canonicalization depends on ordering too much, I filed as https://bugs.llvm.org/show_bug.cgi?id=49590

The other is in the mlir-tblgen/pattern.mlir example, where the test was depending on ambiguous folding order of the two canonicalizations:

def TestNamedPatternRule : Pat<(OpA $input, $attr), (OpB $input, $attr)>;
def : Pat<(OpA (OpA $input, $attr), $bttr), (OpB $input, $bttr)>;

This seemed like a really weird test, so I just changed the testcase to match the expected output. Alternate suggestions on how to fix this are welcome!

bondhugula added a subscriber: bondhugula.Mar 14 2021, 1:36 PM
bondhugula added inline comments.
mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp
149

int -> unsigned while at this?

156–164

Instead of adding them in pre-order and reversing, what happens if used post order while iterating over the ops of each block in reverse? Even for pre-order, we could have an option to traverse the ops of a block in reverse so that the contents of the vector won't have to be moved around later?

bondhugula added inline comments.Mar 14 2021, 1:40 PM
mlir/include/mlir/Transforms/FoldUtils.h
36

This comment doesn't appear to shed much light. Trivially, any constant op that isn't dead could be used for folding. Also, it doesn't say where its discovery/results go.

rriddle added inline comments.Mar 14 2021, 1:41 PM
mlir/include/mlir/Transforms/FoldUtils.h
37

nit: What about naming this something like: processExistingConstants? When I originally read the discover part, I wasn't sure if this also moved the constants to the insertion region. (I don't feel that strongly either way).

mlir/lib/Transforms/Utils/FoldUtils.cpp
94

nit: Spell out auto here.

97

nit: Block?

103

nit: Spell out auto here.

131

Can we just move these first two checks to m_Constant? They are faster than checking the trait.

155

nit: Spell out auto here and below?

mlir/test/Transforms/single-parallel-loop-collapsing.mlir
16–17

Can you just update these(and the other newly broken cases) to CHECK-DAG?

rriddle accepted this revision.Mar 14 2021, 1:44 PM

LGTM after resolving comments.

This revision is now accepted and ready to land.Mar 14 2021, 1:44 PM
Harbormaster completed remote builds in B93721: Diff 330528.Mar 14 2021, 1:56 PM
lattner updated this revision to Diff 330546.Mar 14 2021, 6:20 PM
lattner marked 9 inline comments as done.

Incorporate feedback from River and Uday

mlir/include/mlir/Transforms/FoldUtils.h
36

improved, thanks.

37

Sounds good, also improved the comment.

mlir/lib/Transforms/Utils/FoldUtils.cpp
97

I don't typically spell it out when it is encoded into the name, but sure. Done.

131

Yes, but I'll do that as a separate patch so I can measure it.

mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp
149

I'm not sure who is changing this, but this whole "max iterations" thing is probably a bad idea. it is apparently defaulting to 10 also, which seems a bit excessive to me. I'm going to walk cautiously away from this one :-)

156–164

I don't think that the microoptimization will do anything to help performance, and I like the simplicity of the code. It is very clear and direct.

This revision was landed with ongoing or failed builds.Mar 14 2021, 6:25 PM
Closed by commit rGb5d9a3c92358: [Canonicalizer] Process regions top-down instead of bottom up & reuse existing… (authored by lattner). · Explain Why
This revision was automatically updated to reflect the committed changes.
lattner added a commit: rGb5d9a3c92358: [Canonicalizer] Process regions top-down instead of bottom up & reuse existing….
lattner added a comment.Mar 14 2021, 6:25 PM

Committed in b5d9a3c92358, thank you for the review! I'll change m_Constant now.

Harbormaster completed remote builds in B93734: Diff 330546.Mar 14 2021, 6:56 PM
ftynse added a reverting change: rG40d8e4d3f992: Revert "[Canonicalizer] Process regions top-down instead of bottom up & reuse….Mar 15 2021, 2:28 AM
ftynse added a subscriber: ftynse.Mar 15 2021, 2:30 AM

This introduced a memory error and had to be rolled back. The error is visible under ASAN on several tests, here's mlir-opt -split-input-file -convert-linalg-to-spirv -canonicalize -verify-diagnostics mlir/test/Conversion/LinalgToSPIRV/linalg-to-spirv.mlir for example.

==2856919==ERROR: AddressSanitizer: heap-use-after-free on address 0x607000002128 at pc 0x000006cdb377 bp 0x7ffefa776480 sp 0x7ffefa776478
READ of size 4 at 0x607000002128 thread T0
    #0 0x6cdb376 in mlir::Operation::numTrailingObjects(llvm::trailing_objects_internal::TrailingObjectsBase::OverloadToken<mlir::BlockOperand>) const /home/zinenko/llvm-project/mlir/include/mlir/IR/Operation.h:747:12
    #1 0x6cdb2f4 in unsigned long llvm::TrailingObjects<mlir::Operation, mlir::BlockOperand, mlir::Region, mlir::detail::OperandStorage>::callNumTrailingObjects<mlir::BlockOperand>(mlir::Operation const*, llvm::trailing_objects_internal::TrailingObjectsBase::OverloadToken<mlir::BlockOperand>) /home/zinenko/llvm-project/llvm/include/llvm/Support/TrailingObjects.h:268:17
    #2 0x6cdb261 in llvm::trailing_objects_internal::TrailingObjectsImpl<8, mlir::Operation, llvm::TrailingObjects<mlir::Operation, mlir::BlockOperand, mlir::Region, mlir::detail::OperandStorage>, mlir::BlockOperand, mlir::Region, mlir::detail::OperandStorage>::getTrailingObjectsImpl(mlir::Operation*, llvm::trailing_objects_internal::TrailingObjectsBase::OverloadToken<mlir::Region>) /home/zinenko/llvm-project/llvm/include/llvm/Support/TrailingObjects.h:164:17
    #3 0x6ce8dd4 in mlir::Region* llvm::TrailingObjects<mlir::Operation, mlir::BlockOperand, mlir::Region, mlir::detail::OperandStorage>::getTrailingObjects<mlir::Region>() /home/zinenko/llvm-project/llvm/include/llvm/Support/TrailingObjects.h:301:12
    #4 0x6cbcc18 in mlir::Operation::getRegions() /home/zinenko/llvm-project/mlir/include/mlir/IR/Operation.h:430:21
    #5 0xe2d49c8 in mlir::detail::walk(mlir::Operation*, llvm::function_ref<mlir::WalkResult (mlir::Operation*)>, mlir::WalkOrder) /home/zinenko/llvm-project/mlir/lib/IR/Visitors.cpp:146:27
    #6 0xdc5a2af in std::enable_if<llvm::is_one_of<mlir::Operation*, mlir::Operation*, mlir::Region*, mlir::Block*>::value, mlir::WalkResult>::type mlir::detail::walk<(mlir::WalkOrder)0, mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0&, mlir::Operation*, mlir::WalkResult>(mlir::Operation*, mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0&) /home/zinenko/llvm-project/mlir/include/mlir/IR/Visitors.h:134:10
    #7 0xdc59e8e in std::enable_if<std::is_same<mlir::WalkResult, mlir::WalkResult>::value, mlir::WalkResult>::type mlir::Block::walk<(mlir::WalkOrder)0, mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0&, mlir::WalkResult>(llvm::ilist_iterator<llvm::ilist_detail::node_options<mlir::Operation, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<mlir::Operation, false, false, void>, false, false>, mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0&) /home/zinenko/llvm-project/mlir/include/mlir/IR/Block.h:305:11
    #8 0xdc5987b in mlir::WalkResult mlir::Block::walk<(mlir::WalkOrder)0, mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0&, mlir::WalkResult>(mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0&) /home/zinenko/llvm-project/mlir/include/mlir/IR/Block.h:268:12
    #9 0xdc54738 in std::enable_if<std::is_same<mlir::WalkResult, mlir::WalkResult>::value, mlir::WalkResult>::type mlir::Region::walk<(mlir::WalkOrder)0, mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0, mlir::WalkResult>(mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0&&) /home/zinenko/llvm-project/mlir/include/mlir/IR/Region.h:278:17
    #10 0xdc5405b in mlir::OperationFolder::processExistingConstants(mlir::Region&) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/FoldUtils.cpp:130:10
    #11 0xdc5425a in mlir::OperationFolder::processExistingConstants(mlir::Region&) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/FoldUtils.cpp:158:7
    #12 0xdc6f0fd in (anonymous namespace)::GreedyPatternRewriteDriver::simplify(llvm::MutableArrayRef<mlir::Region>, int) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp:146:12
    #13 0xdc6e662 in mlir::applyPatternsAndFoldGreedily(llvm::MutableArrayRef<mlir::Region>, mlir::FrozenRewritePatternList const&, unsigned int) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp:273:27
    #14 0xdc6ea94 in mlir::applyPatternsAndFoldGreedily(llvm::MutableArrayRef<mlir::Region>, mlir::FrozenRewritePatternList const&) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp:251:10
    #15 0xda2e2b7 in (anonymous namespace)::Canonicalizer::runOnOperation() /home/zinenko/llvm-project/mlir/lib/Transforms/Canonicalizer.cpp:34:11
    #16 0xd8c9792 in mlir::detail::OpToOpPassAdaptor::run(mlir::Pass*, mlir::Operation*, mlir::AnalysisManager, bool, unsigned int) /home/zinenko/llvm-project/mlir/lib/Pass/Pass.cpp:402:11
    #17 0xd8cad54 in mlir::detail::OpToOpPassAdaptor::runPipeline(llvm::iterator_range<llvm::pointee_iterator<std::unique_ptr<mlir::Pass, std::default_delete<mlir::Pass> >*, mlir::Pass> >, mlir::Operation*, mlir::AnalysisManager, bool, unsigned int, mlir::PassInstrumentor*, mlir::PassInstrumentation::PipelineParentInfo const*) /home/zinenko/llvm-project/mlir/lib/Pass/Pass.cpp:444:16
    #18 0xd8d2fbe in mlir::PassManager::run(mlir::Operation*) /home/zinenko/llvm-project/mlir/lib/Pass/Pass.cpp:895:13
    #19 0xd7ec818 in performActions(llvm::raw_ostream&, bool, bool, llvm::SourceMgr&, mlir::MLIRContext*, mlir::PassPipelineCLParser const&) /home/zinenko/llvm-project/mlir/lib/Support/MlirOptMain.cpp:76:17
    #20 0xd7e8b83 in processBuffer(llvm::raw_ostream&, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, bool, bool, bool, bool, mlir::PassPipelineCLParser const&, mlir::DialectRegistry&) /home/zinenko/llvm-project/mlir/lib/Support/MlirOptMain.cpp:119:9
    #21 0xd7ed824 in mlir::MlirOptMain(llvm::raw_ostream&, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, mlir::PassPipelineCLParser const&, mlir::DialectRegistry&, bool, bool, bool, bool, bool)::$_0::operator()(std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&) const /home/zinenko/llvm-project/mlir/lib/Support/MlirOptMain.cpp:140:18
    #22 0xd7ed304 in mlir::LogicalResult llvm::function_ref<mlir::LogicalResult (std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&)>::callback_fn<mlir::MlirOptMain(llvm::raw_ostream&, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, mlir::PassPipelineCLParser const&, mlir::DialectRegistry&, bool, bool, bool, bool, bool)::$_0>(long, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&) /home/zinenko/llvm-project/llvm/include/llvm/ADT/STLExtras.h:185:12
    #23 0xddb46a9 in llvm::function_ref<mlir::LogicalResult (std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&)>::operator()(std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&) const /home/zinenko/llvm-project/llvm/include/llvm/ADT/STLExtras.h:209:12
    #24 0xddb41fd in mlir::splitAndProcessBuffer(std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::function_ref<mlir::LogicalResult (std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&)>, llvm::raw_ostream&) /home/zinenko/llvm-project/mlir/lib/Support/ToolUtilities.cpp:43:16
    #25 0xd7e82ec in mlir::MlirOptMain(llvm::raw_ostream&, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, mlir::PassPipelineCLParser const&, mlir::DialectRegistry&, bool, bool, bool, bool, bool) /home/zinenko/llvm-project/mlir/lib/Support/MlirOptMain.cpp:137:12
    #26 0xd7eb5fc in mlir::MlirOptMain(int, char**, llvm::StringRef, mlir::DialectRegistry&, bool) /home/zinenko/llvm-project/mlir/lib/Support/MlirOptMain.cpp:251:14
    #27 0x602a4f0 in main /home/zinenko/llvm-project/mlir/tools/mlir-opt/mlir-opt.cpp:189:17
    #28 0x7f5c74a60d09 in __libc_start_main csu/../csu/libc-start.c:308:16
    #29 0x5f7df79 in _start (/home/zinenko/llvm-project/build2/bin/mlir-opt+0x5f7df79)

0x607000002128 is located 56 bytes inside of 80-byte region [0x6070000020f0,0x607000002140)
freed by thread T0 here:
    #0 0x5ff741d in free llvm/compiler-rt/lib/asan/asan_malloc_linux.cpp:123:3
    #1 0xe1e38c7 in mlir::Operation::destroy() /home/zinenko/llvm-project/mlir/lib/IR/Operation.cpp:206:3
    #2 0xe1e62e4 in llvm::ilist_traits<mlir::Operation>::deleteNode(mlir::Operation*) /home/zinenko/llvm-project/mlir/lib/IR/Operation.cpp:429:7
    #3 0x9c23f60 in llvm::iplist_impl<llvm::simple_ilist<mlir::Operation>, llvm::ilist_traits<mlir::Operation> >::erase(llvm::ilist_iterator<llvm::ilist_detail::node_options<mlir::Operation, false, false, void>, false, false>) /home/zinenko/llvm-project/llvm/include/llvm/ADT/ilist.h:268:5
    #4 0xe20c96e in llvm::iplist_impl<llvm::simple_ilist<mlir::Operation>, llvm::ilist_traits<mlir::Operation> >::erase(mlir::Operation*) /home/zinenko/llvm-project/llvm/include/llvm/ADT/ilist.h:272:39
    #5 0xe1e68c3 in mlir::Operation::erase() /home/zinenko/llvm-project/mlir/lib/IR/Operation.cpp:478:29
    #6 0xdc5b5f3 in mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_2::operator()(mlir::Operation*, mlir::Attribute) const /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/FoldUtils.cpp:114:11
    #7 0xdc5a9bd in mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0::operator()(mlir::Operation*) const /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/FoldUtils.cpp:134:7
    #8 0xdc5a58b in mlir::WalkResult llvm::function_ref<mlir::WalkResult (mlir::Operation*)>::callback_fn<mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0>(long, mlir::Operation*) /home/zinenko/llvm-project/llvm/include/llvm/ADT/STLExtras.h:185:12
    #9 0xe2d5d2a in llvm::function_ref<mlir::WalkResult (mlir::Operation*)>::operator()(mlir::Operation*) const /home/zinenko/llvm-project/llvm/include/llvm/ADT/STLExtras.h:209:12
    #10 0xe2d4801 in mlir::detail::walk(mlir::Operation*, llvm::function_ref<mlir::WalkResult (mlir::Operation*)>, mlir::WalkOrder) /home/zinenko/llvm-project/mlir/lib/IR/Visitors.cpp:137:25
    #11 0xdc5a2af in std::enable_if<llvm::is_one_of<mlir::Operation*, mlir::Operation*, mlir::Region*, mlir::Block*>::value, mlir::WalkResult>::type mlir::detail::walk<(mlir::WalkOrder)0, mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0&, mlir::Operation*, mlir::WalkResult>(mlir::Operation*, mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0&) /home/zinenko/llvm-project/mlir/include/mlir/IR/Visitors.h:134:10
    #12 0xdc59e8e in std::enable_if<std::is_same<mlir::WalkResult, mlir::WalkResult>::value, mlir::WalkResult>::type mlir::Block::walk<(mlir::WalkOrder)0, mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0&, mlir::WalkResult>(llvm::ilist_iterator<llvm::ilist_detail::node_options<mlir::Operation, false, false, void>, false, false>, llvm::ilist_iterator<llvm::ilist_detail::node_options<mlir::Operation, false, false, void>, false, false>, mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0&) /home/zinenko/llvm-project/mlir/include/mlir/IR/Block.h:305:11
    #13 0xdc5987b in mlir::WalkResult mlir::Block::walk<(mlir::WalkOrder)0, mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0&, mlir::WalkResult>(mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0&) /home/zinenko/llvm-project/mlir/include/mlir/IR/Block.h:268:12
    #14 0xdc54738 in std::enable_if<std::is_same<mlir::WalkResult, mlir::WalkResult>::value, mlir::WalkResult>::type mlir::Region::walk<(mlir::WalkOrder)0, mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0, mlir::WalkResult>(mlir::OperationFolder::processExistingConstants(mlir::Region&)::$_0&&) /home/zinenko/llvm-project/mlir/include/mlir/IR/Region.h:278:17
    #15 0xdc5405b in mlir::OperationFolder::processExistingConstants(mlir::Region&) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/FoldUtils.cpp:130:10
    #16 0xdc5425a in mlir::OperationFolder::processExistingConstants(mlir::Region&) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/FoldUtils.cpp:158:7
    #17 0xdc6f0fd in (anonymous namespace)::GreedyPatternRewriteDriver::simplify(llvm::MutableArrayRef<mlir::Region>, int) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp:146:12
    #18 0xdc6e662 in mlir::applyPatternsAndFoldGreedily(llvm::MutableArrayRef<mlir::Region>, mlir::FrozenRewritePatternList const&, unsigned int) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp:273:27
    #19 0xdc6ea94 in mlir::applyPatternsAndFoldGreedily(llvm::MutableArrayRef<mlir::Region>, mlir::FrozenRewritePatternList const&) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp:251:10
    #20 0xda2e2b7 in (anonymous namespace)::Canonicalizer::runOnOperation() /home/zinenko/llvm-project/mlir/lib/Transforms/Canonicalizer.cpp:34:11
    #21 0xd8c9792 in mlir::detail::OpToOpPassAdaptor::run(mlir::Pass*, mlir::Operation*, mlir::AnalysisManager, bool, unsigned int) /home/zinenko/llvm-project/mlir/lib/Pass/Pass.cpp:402:11
    #22 0xd8cad54 in mlir::detail::OpToOpPassAdaptor::runPipeline(llvm::iterator_range<llvm::pointee_iterator<std::unique_ptr<mlir::Pass, std::default_delete<mlir::Pass> >*, mlir::Pass> >, mlir::Operation*, mlir::AnalysisManager, bool, unsigned int, mlir::PassInstrumentor*, mlir::PassInstrumentation::PipelineParentInfo const*) /home/zinenko/llvm-project/mlir/lib/Pass/Pass.cpp:444:16
    #23 0xd8d2fbe in mlir::PassManager::run(mlir::Operation*) /home/zinenko/llvm-project/mlir/lib/Pass/Pass.cpp:895:13
    #24 0xd7ec818 in performActions(llvm::raw_ostream&, bool, bool, llvm::SourceMgr&, mlir::MLIRContext*, mlir::PassPipelineCLParser const&) /home/zinenko/llvm-project/mlir/lib/Support/MlirOptMain.cpp:76:17
    #25 0xd7e8b83 in processBuffer(llvm::raw_ostream&, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, bool, bool, bool, bool, mlir::PassPipelineCLParser const&, mlir::DialectRegistry&) /home/zinenko/llvm-project/mlir/lib/Support/MlirOptMain.cpp:119:9
    #26 0xd7ed824 in mlir::MlirOptMain(llvm::raw_ostream&, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, mlir::PassPipelineCLParser const&, mlir::DialectRegistry&, bool, bool, bool, bool, bool)::$_0::operator()(std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&) const /home/zinenko/llvm-project/mlir/lib/Support/MlirOptMain.cpp:140:18
    #27 0xd7ed304 in mlir::LogicalResult llvm::function_ref<mlir::LogicalResult (std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&)>::callback_fn<mlir::MlirOptMain(llvm::raw_ostream&, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, mlir::PassPipelineCLParser const&, mlir::DialectRegistry&, bool, bool, bool, bool, bool)::$_0>(long, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&) /home/zinenko/llvm-project/llvm/include/llvm/ADT/STLExtras.h:185:12
    #28 0xddb46a9 in llvm::function_ref<mlir::LogicalResult (std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&)>::operator()(std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&) const /home/zinenko/llvm-project/llvm/include/llvm/ADT/STLExtras.h:209:12
    #29 0xddb41fd in mlir::splitAndProcessBuffer(std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::function_ref<mlir::LogicalResult (std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&)>, llvm::raw_ostream&) /home/zinenko/llvm-project/mlir/lib/Support/ToolUtilities.cpp:43:16

previously allocated by thread T0 here:
    #0 0x5ff769d in malloc llvm/compiler-rt/lib/asan/asan_malloc_linux.cpp:145:3
    #1 0xe1e153f in mlir::Operation::create(mlir::Location, mlir::OperationName, mlir::TypeRange, mlir::ValueRange, mlir::DictionaryAttr, mlir::BlockRange, unsigned int) /home/zinenko/llvm-project/mlir/lib/IR/Operation.cpp:136:46
    #2 0xe1e292f in mlir::Operation::create(mlir::Location, mlir::OperationName, mlir::TypeRange, mlir::ValueRange, mlir::DictionaryAttr, mlir::BlockRange, mlir::RegionRange) /home/zinenko/llvm-project/mlir/lib/IR/Operation.cpp:94:19
    #3 0xe1e214c in mlir::Operation::create(mlir::OperationState const&) /home/zinenko/llvm-project/mlir/lib/IR/Operation.cpp:83:10
    #4 0xdeb9363 in mlir::OpBuilder::createOperation(mlir::OperationState const&) /home/zinenko/llvm-project/mlir/lib/IR/Builders.cpp:393:17
    #5 0xaa6b047 in mlir::spirv::ConstantOp mlir::OpBuilder::create<mlir::spirv::ConstantOp, mlir::Type&, mlir::IntegerAttr>(mlir::Location, mlir::Type&, mlir::IntegerAttr&&) /home/zinenko/llvm-project/mlir/include/mlir/IR/Builders.h:399:16
    #6 0xab24765 in mlir::spirv::linearizeIndex(mlir::ValueRange, llvm::ArrayRef<long>, long, mlir::Location, mlir::OpBuilder&) /home/zinenko/llvm-project/mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp:623:35
    #7 0xab25a50 in mlir::spirv::getElementPtr(mlir::SPIRVTypeConverter&, mlir::MemRefType, mlir::Value, mlir::ValueRange, mlir::Location, mlir::OpBuilder&) /home/zinenko/llvm-project/mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp:660:9
    #8 0xbd11b6b in (anonymous namespace)::SingleWorkgroupReduction::matchAndRewrite(mlir::linalg::GenericOp, llvm::ArrayRef<mlir::Value>, mlir::ConversionPatternRewriter&) const /home/zinenko/llvm-project/mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRV.cpp:148:27
    #9 0x8798d65 in mlir::OpConversionPattern<mlir::linalg::GenericOp>::matchAndRewrite(mlir::Operation*, llvm::ArrayRef<mlir::Value>, mlir::ConversionPatternRewriter&) const /home/zinenko/llvm-project/mlir/include/mlir/Transforms/DialectConversion.h:398:12
    #10 0xdbb350b in mlir::ConversionPattern::matchAndRewrite(mlir::Operation*, mlir::PatternRewriter&) const /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/DialectConversion.cpp:1490:10
    #11 0x1494adb0 in mlir::PatternApplicator::matchAndRewrite(mlir::Operation*, mlir::PatternRewriter&, llvm::function_ref<bool (mlir::Pattern const&)>, llvm::function_ref<void (mlir::Pattern const&)>, llvm::function_ref<mlir::LogicalResult (mlir::Pattern const&)>) /home/zinenko/llvm-project/mlir/lib/Rewrite/PatternApplicator.cpp:168:22
    #12 0xdbd5020 in (anonymous namespace)::OperationLegalizer::legalizeWithPattern(mlir::Operation*, mlir::ConversionPatternRewriter&) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/DialectConversion.cpp:1766:21
    #13 0xdbd2d48 in (anonymous namespace)::OperationLegalizer::legalize(mlir::Operation*, mlir::ConversionPatternRewriter&) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/DialectConversion.cpp:1683:17
    #14 0xdbd040b in (anonymous namespace)::OperationConverter::convert(mlir::ConversionPatternRewriter&, mlir::Operation*) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/DialectConversion.cpp:2178:26
    #15 0xdbbb00d in (anonymous namespace)::OperationConverter::convertOperations(llvm::ArrayRef<mlir::Operation*>) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/DialectConversion.cpp:2223:16
    #16 0xdbbbaf7 in mlir::applyFullConversion(llvm::ArrayRef<mlir::Operation*>, mlir::ConversionTarget&, mlir::FrozenRewritePatternList const&) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/DialectConversion.cpp:2778:22
    #17 0xdbbbe8f in mlir::applyFullConversion(mlir::Operation*, mlir::ConversionTarget&, mlir::FrozenRewritePatternList const&) /home/zinenko/llvm-project/mlir/lib/Transforms/Utils/DialectConversion.cpp:2783:10
    #18 0xbd0cdeb in (anonymous namespace)::LinalgToSPIRVPass::runOnOperation() /home/zinenko/llvm-project/mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.cpp:44:14
    #19 0xd8c9792 in mlir::detail::OpToOpPassAdaptor::run(mlir::Pass*, mlir::Operation*, mlir::AnalysisManager, bool, unsigned int) /home/zinenko/llvm-project/mlir/lib/Pass/Pass.cpp:402:11
    #20 0xd8cad54 in mlir::detail::OpToOpPassAdaptor::runPipeline(llvm::iterator_range<llvm::pointee_iterator<std::unique_ptr<mlir::Pass, std::default_delete<mlir::Pass> >*, mlir::Pass> >, mlir::Operation*, mlir::AnalysisManager, bool, unsigned int, mlir::PassInstrumentor*, mlir::PassInstrumentation::PipelineParentInfo const*) /home/zinenko/llvm-project/mlir/lib/Pass/Pass.cpp:444:16
    #21 0xd8d2fbe in mlir::PassManager::run(mlir::Operation*) /home/zinenko/llvm-project/mlir/lib/Pass/Pass.cpp:895:13
    #22 0xd7ec818 in performActions(llvm::raw_ostream&, bool, bool, llvm::SourceMgr&, mlir::MLIRContext*, mlir::PassPipelineCLParser const&) /home/zinenko/llvm-project/mlir/lib/Support/MlirOptMain.cpp:76:17
    #23 0xd7e8b83 in processBuffer(llvm::raw_ostream&, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, bool, bool, bool, bool, mlir::PassPipelineCLParser const&, mlir::DialectRegistry&) /home/zinenko/llvm-project/mlir/lib/Support/MlirOptMain.cpp:119:9
    #24 0xd7ed824 in mlir::MlirOptMain(llvm::raw_ostream&, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, mlir::PassPipelineCLParser const&, mlir::DialectRegistry&, bool, bool, bool, bool, bool)::$_0::operator()(std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&) const /home/zinenko/llvm-project/mlir/lib/Support/MlirOptMain.cpp:140:18
    #25 0xd7ed304 in mlir::LogicalResult llvm::function_ref<mlir::LogicalResult (std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&)>::callback_fn<mlir::MlirOptMain(llvm::raw_ostream&, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, mlir::PassPipelineCLParser const&, mlir::DialectRegistry&, bool, bool, bool, bool, bool)::$_0>(long, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&) /home/zinenko/llvm-project/llvm/include/llvm/ADT/STLExtras.h:185:12
    #26 0xddb46a9 in llvm::function_ref<mlir::LogicalResult (std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&)>::operator()(std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&) const /home/zinenko/llvm-project/llvm/include/llvm/ADT/STLExtras.h:209:12
    #27 0xddb41fd in mlir::splitAndProcessBuffer(std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::function_ref<mlir::LogicalResult (std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::raw_ostream&)>, llvm::raw_ostream&) /home/zinenko/llvm-project/mlir/lib/Support/ToolUtilities.cpp:43:16
    #28 0xd7e82ec in mlir::MlirOptMain(llvm::raw_ostream&, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, mlir::PassPipelineCLParser const&, mlir::DialectRegistry&, bool, bool, bool, bool, bool) /home/zinenko/llvm-project/mlir/lib/Support/MlirOptMain.cpp:137:12
    #29 0xd7eb5fc in mlir::MlirOptMain(int, char**, llvm::StringRef, mlir::DialectRegistry&, bool) /home/zinenko/llvm-project/mlir/lib/Support/MlirOptMain.cpp:251:14

SUMMARY: AddressSanitizer: heap-use-after-free
ftynse added a comment.Mar 15 2021, 2:34 AM

Here's the list of broken tests

mlir/test/Conversion/LinalgToSPIRV/linalg-to-spirv.mlir
mlir/test/Conversion/StandardToSPIRV/alloc.mlir
mlir/test/Dialect/Linalg/bufferize.mlir
mlir/test/Dialect/Linalg/fusion-2-level.mlir
mlir/test/Dialect/Linalg/fusion-sequence.mlir
mlir/test/Dialect/Linalg/fusion.mlir
mlir/test/Dialect/Linalg/tile-and-fuse-tensors.mlir
mlir/test/Dialect/Quant/convert-const.mlir
mlir/test/Dialect/SPIRV/Transforms/canonicalize.mlir
mlir/test/Dialect/Shape/canonicalize.mlir
mlir/test/Integration/Dialect/Async/CPU/microbench-linalg-async-parallel-for.mlir
mlir/test/Integration/Dialect/Async/CPU/test-async-parallel-for-2d.mlir
mlir/test/Integration/Dialect/Linalg/CPU/benchmark_matmul.mlir
mlir/test/Integration/Dialect/Linalg/CPU/benchmark_matmul_column_major.mlir
mlir/test/Integration/Dialect/Linalg/CPU/benchmark_matmul_column_major_as_row_major.mlir
mlir/test/Integration/Dialect/Linalg/CPU/benchmark_matmul_i8_i8_i32.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-call.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-input-ncw-filter-wcf-call.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-input-nwc-filter-wcf-call.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-ncw-call.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-nwc-call.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-call.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-input-nchw-filter-hwcf-call.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-input-nhwc-filter-hwcf-call.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-nchw-call.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-nhwc-call.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-call.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-input-ncdhw-filter-dhwcf-call.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-input-ndhwc-filter-dhwcf-call.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-ncdhw-call.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-ndhwc-call.mlir
mlir/test/Integration/Dialect/Linalg/CPU/test-tensor-matmul.mlir
mlir/test/Integration/Dialect/Standard/CPU/test-ceil-floor-pos-neg.mlir
mlir/test/Integration/Dialect/Vector/CPU/test-transfer-read-2d.mlir
mlir/test/Integration/Dialect/Vector/CPU/test-transfer-to-loops.mlir
mlir/test/Integration/Dialect/Vector/CPU/test-vector-distribute.mlir
mlir/test/Integration/Sparse/CPU/matrix-market-example.mlir
mlir/test/Integration/Sparse/CPU/sparse_sampled_matmul.mlir
mlir/test/Integration/Sparse/CPU/sparse_sum.mlir
mlir/test/Transforms/canonicalize.mlir
mlir/test/Transforms/parallel-loop-collapsing.mlir
mlir/test/Transforms/scf-loop-unroll.mlir
mlir/test/Transforms/single-parallel-loop-collapsing.mlir
mlir/test/Transforms/test-canonicalize.mlir
mlir/test/mlir-cpu-runner/async-value.mlir
mlir/test/mlir-cpu-runner/async.mlir
mlir/test/mlir-cpu-runner/sgemm_naive_codegen.mlir
lattner added a comment.Mar 15 2021, 10:23 AM

Huh ok, thank you for the revert Alex, i'll take a look at some point when I get a chance.

lattner mentioned this in D99006: [Canonicalizer] Process regions top-down instead of bottom up & reuse existing constants..Mar 19 2021, 9:22 PM
lattner mentioned this in rG361b7d125b43: [Canonicalizer] Process regions top-down instead of bottom up & reuse existing….Mar 20 2021, 4:36 PM

Revision Contents

PathSize
mlir/
include/
mlir/
Transforms/
6 lines
lib/
Transforms/
Utils/
98 lines
29 lines
test/
Conversion/
StandardToSPIRV/
2 lines
VectorToSCF/
13 lines
Dialect/
Affine/
6 lines
Linalg/
2 lines
2 lines
Quant/
6 lines
SCF/
10 lines
SPIRV/
Transforms/
63 lines
Tensor/
8 lines
Vector/
12 lines
7 lines
10 lines
12 lines
12 lines
6 lines
Transforms/
12 lines
12 lines
14 lines
19 lines
mlir-tblgen/
6 lines

Diff 330547

mlir/include/mlir/Transforms/FoldUtils.h

Show All 17 Lines
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/IR/DialectInterface.h" #include "mlir/IR/DialectInterface.h"
#include "mlir/Interfaces/FoldInterfaces.h" #include "mlir/Interfaces/FoldInterfaces.h"
namespace mlir { namespace mlir {
class Operation; class Operation;
class Value; class Value;
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// OperationFolder // OperationFolder
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
/// A utility class for folding operations, and unifying duplicated constants /// A utility class for folding operations, and unifying duplicated constants
/// generated along the way. /// generated along the way.
class OperationFolder { class OperationFolder {
public: public:
OperationFolder(MLIRContext *ctx) : interfaces(ctx) {} OperationFolder(MLIRContext *ctx) : interfaces(ctx) {}
/// Scan the specified region for constants that can be used in folding,
bondhugulaUnsubmitted
Done
ReplyInline Actions

This comment doesn't appear to shed much light. Trivially, any constant op that isn't dead could be used for folding. Also, it doesn't say where its discovery/results go.

bondhugula: This comment doesn't appear to shed much light. Trivially, any constant op that isn't dead…
lattnerAuthorUnsubmitted
Done
ReplyInline Actions

improved, thanks.

lattner: improved, thanks.
/// moving them to the entry block and adding them to our known-constants
rriddleUnsubmitted
Done
ReplyInline Actions

nit: What about naming this something like: processExistingConstants? When I originally read the discover part, I wasn't sure if this also moved the constants to the insertion region. (I don't feel that strongly either way).

rriddle: nit: What about naming this something like: `processExistingConstants`? When I originally read…
lattnerAuthorUnsubmitted
Done
ReplyInline Actions

Sounds good, also improved the comment.

lattner: Sounds good, also improved the comment.
/// table.
void processExistingConstants(Region &region);
/// Tries to perform folding on the given `op`, including unifying /// Tries to perform folding on the given `op`, including unifying
/// deduplicated constants. If successful, replaces `op`'s uses with /// deduplicated constants. If successful, replaces `op`'s uses with
/// folded results, and returns success. `preReplaceAction` is invoked on `op` /// folded results, and returns success. `preReplaceAction` is invoked on `op`
/// before it is replaced. 'processGeneratedConstants' is invoked for any new /// before it is replaced. 'processGeneratedConstants' is invoked for any new
/// operations generated when folding. If the op was completely folded it is /// operations generated when folding. If the op was completely folded it is
/// erased. If it is just updated in place, `inPlaceUpdate` is set to true. /// erased. If it is just updated in place, `inPlaceUpdate` is set to true.
LogicalResult LogicalResult
tryToFold(Operation *op, tryToFold(Operation *op,
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

mlir/lib/Transforms/Utils/FoldUtils.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines if (ConstantOp::isBuildableWith(value, type))
return builder.create<ConstantOp>(loc, type, value); return builder.create<ConstantOp>(loc, type, value);
return nullptr; return nullptr;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// OperationFolder // OperationFolder
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Scan the specified region for constants that can be used in folding,
/// moving them to the entry block and adding them to our known-constants
/// table.
void OperationFolder::processExistingConstants(Region &region) {
if (region.empty())
return;
// March the constant insertion point forward, moving all constants to the
rriddleUnsubmitted
Done
ReplyInline Actions

nit: Spell out auto here.

rriddle: nit: Spell out auto here.
// top of the block, but keeping them in their order of discovery.
Region *insertRegion = getInsertionRegion(interfaces, &region.front());
auto &uniquedConstants = foldScopes[insertRegion];
rriddleUnsubmitted
Done
ReplyInline Actions

nit: Block?

rriddle: nit: Block?
lattnerAuthorUnsubmitted
Done
ReplyInline Actions

I don't typically spell it out when it is encoded into the name, but sure. Done.

lattner: I don't typically spell it out when it is encoded into the name, but sure. Done.
Block &insertBlock = insertRegion->front();
Block::iterator constantIterator = insertBlock.begin();
// Process each constant that we discover in this region.
auto processConstant = [&](Operation *op, Attribute value) {
rriddleUnsubmitted
Done
ReplyInline Actions

nit: Spell out auto here.

rriddle: nit: Spell out auto here.
// Check to see if we already have an instance of this constant.
Operation *&constOp = uniquedConstants[std::make_tuple(
op->getDialect(), value, op->getResult(0).getType())];
// If we already have an instance of this constant, CSE/delete this one as
// we go.
if (constOp) {
if (constantIterator == Block::iterator(op))
++constantIterator; // Don't invalidate our iterator when scanning.
op->getResult(0).replaceAllUsesWith(constOp->getResult(0));
op->erase();
return;
}
// Otherwise, remember that we have this constant.
constOp = op;
referencedDialects[op].push_back(op->getDialect());
// If the constant isn't already at the insertion point then move it up.
if (constantIterator == insertBlock.end() || &*constantIterator != op)
op->moveBefore(&insertBlock, constantIterator);
else
++constantIterator; // It was pointing at the constant.
};
SmallVector<Operation *> isolatedOps;
region.walk<WalkOrder::PreOrder>([&](Operation *op) {
// If this is a constant, process it.
rriddleUnsubmitted
Done
ReplyInline Actions

Can we just move these first two checks to m_Constant? They are faster than checking the trait.

rriddle: Can we just move these first two checks to m_Constant? They are faster than checking the trait.
lattnerAuthorUnsubmitted
Done
ReplyInline Actions

Yes, but I'll do that as a separate patch so I can measure it.

lattner: Yes, but I'll do that as a separate patch so I can measure it.
Attribute value;
if (op->getNumOperands() == 0 && op->getNumResults() == 1 &&
matchPattern(op, m_Constant(&value))) {
processConstant(op, value);
// We may have deleted the operation, don't check it for regions.
return WalkResult::advance();
}
// If the operation has regions and is isolated, don't recurse into it.
if (op->getNumRegions() != 0) {
auto hasDifferentInsertRegion = [&](Region &region) {
return !region.empty() &&
getInsertionRegion(interfaces, &region.front()) != insertRegion;
};
if (llvm::any_of(op->getRegions(), hasDifferentInsertRegion)) {
isolatedOps.push_back(op);
return WalkResult::skip();
}
}
// Otherwise keep going.
return WalkResult::advance();
});
rriddleUnsubmitted
Done
ReplyInline Actions

nit: Spell out auto here and below?

rriddle: nit: Spell out auto here and below?
// Process regions in any isolated ops separately.
for (Operation *isolated : isolatedOps) {
for (Region &region : isolated->getRegions())
processExistingConstants(region);
}
}
LogicalResult OperationFolder::tryToFold( LogicalResult OperationFolder::tryToFold(
Operation *op, function_ref<void(Operation *)> processGeneratedConstants, Operation *op, function_ref<void(Operation *)> processGeneratedConstants,
function_ref<void(Operation *)> preReplaceAction, bool *inPlaceUpdate) { function_ref<void(Operation *)> preReplaceAction, bool *inPlaceUpdate) {
if (inPlaceUpdate) if (inPlaceUpdate)
*inPlaceUpdate = false; *inPlaceUpdate = false;
// If this is a unique'd constant, return failure as we know that it has // If this is a unique'd constant, return failure as we know that it has
// already been folded. // already been folded.
▲ Show 20 Lines • Show All 162 Lines • ▼ Show 20 Lines
/// Try to get or create a new constant entry. On success this returns the /// Try to get or create a new constant entry. On success this returns the
/// constant operation value, nullptr otherwise. /// constant operation value, nullptr otherwise.
Operation *OperationFolder::tryGetOrCreateConstant( Operation *OperationFolder::tryGetOrCreateConstant(
ConstantMap &uniquedConstants, Dialect *dialect, OpBuilder &builder, ConstantMap &uniquedConstants, Dialect *dialect, OpBuilder &builder,
Attribute value, Type type, Location loc) { Attribute value, Type type, Location loc) {
// Check if an existing mapping already exists. // Check if an existing mapping already exists.
auto constKey = std::make_tuple(dialect, value, type); auto constKey = std::make_tuple(dialect, value, type);
auto *&constInst = uniquedConstants[constKey]; auto *&constOp = uniquedConstants[constKey];
if (constInst) if (constOp)
return constInst; return constOp;
// If one doesn't exist, try to materialize one. // If one doesn't exist, try to materialize one.
if (!(constInst = materializeConstant(dialect, builder, value, type, loc))) if (!(constOp = materializeConstant(dialect, builder, value, type, loc)))
return nullptr; return nullptr;
// Check to see if the generated constant is in the expected dialect. // Check to see if the generated constant is in the expected dialect.
auto *newDialect = constInst->getDialect(); auto *newDialect = constOp->getDialect();
if (newDialect == dialect) { if (newDialect == dialect) {
referencedDialects[constInst].push_back(dialect); referencedDialects[constOp].push_back(dialect);
return constInst; return constOp;
} }
// If it isn't, then we also need to make sure that the mapping for the new // If it isn't, then we also need to make sure that the mapping for the new
// dialect is valid. // dialect is valid.
auto newKey = std::make_tuple(newDialect, value, type); auto newKey = std::make_tuple(newDialect, value, type);
// If an existing operation in the new dialect already exists, delete the // If an existing operation in the new dialect already exists, delete the
// materialized operation in favor of the existing one. // materialized operation in favor of the existing one.
if (auto *existingOp = uniquedConstants.lookup(newKey)) { if (auto *existingOp = uniquedConstants.lookup(newKey)) {
constInst->erase(); constOp->erase();
referencedDialects[existingOp].push_back(dialect); referencedDialects[existingOp].push_back(dialect);
return constInst = existingOp; return constOp = existingOp;
} }
// Otherwise, update the new dialect to the materialized operation. // Otherwise, update the new dialect to the materialized operation.
referencedDialects[constInst].assign({dialect, newDialect}); referencedDialects[constOp].assign({dialect, newDialect});
auto newIt = uniquedConstants.insert({newKey, constInst}); auto newIt = uniquedConstants.insert({newKey, constOp});
return newIt.first->second; return newIt.first->second;
} }

mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines for (auto result : op->getResults())
addToWorklist(user); addToWorklist(user);
} }
private: private:
// Look over the provided operands for any defining operations that should // Look over the provided operands for any defining operations that should
// be re-added to the worklist. This function should be called when an // be re-added to the worklist. This function should be called when an
// operation is modified or removed, as it may trigger further // operation is modified or removed, as it may trigger further
// simplifications. // simplifications.
template <typename Operands> void addToWorklist(Operands &&operands) { template <typename Operands>
void addToWorklist(Operands &&operands) {
for (Value operand : operands) { for (Value operand : operands) {
// If the use count of this operand is now < 2, we re-add the defining // If the use count of this operand is now < 2, we re-add the defining
// operation to the worklist. // operation to the worklist.
// TODO: This is based on the fact that zero use operations // TODO: This is based on the fact that zero use operations
// may be deleted, and that single use values often have more // may be deleted, and that single use values often have more
// canonicalization opportunities. // canonicalization opportunities.
if (!operand.use_empty() && !operand.hasOneUse()) if (!operand.use_empty() && !operand.hasOneUse())
continue; continue;
Show All 16 Linesprivate:
OperationFolder folder; OperationFolder folder;
}; };
} // end anonymous namespace } // end anonymous namespace
/// Performs the rewrites while folding and erasing any dead ops. Returns true /// Performs the rewrites while folding and erasing any dead ops. Returns true
/// if the rewrite converges in `maxIterations`. /// if the rewrite converges in `maxIterations`.
bool GreedyPatternRewriteDriver::simplify(MutableArrayRef<Region> regions, bool GreedyPatternRewriteDriver::simplify(MutableArrayRef<Region> regions,
int maxIterations) { int maxIterations) {
// Add the given operation to the worklist. // Perform a prepass over the IR to discover constants.
auto collectOps = [this](Operation *op) { addToWorklist(op); }; for (auto &region : regions)
folder.processExistingConstants(region);
bool changed = false; bool changed = false;
int i = 0; int iteration = 0;
bondhugulaUnsubmitted
Done
ReplyInline Actions

int -> unsigned while at this?

bondhugula: int -> unsigned while at this?
lattnerAuthorUnsubmitted
Done
ReplyInline Actions

I'm not sure who is changing this, but this whole "max iterations" thing is probably a bad idea. it is apparently defaulting to 10 also, which seems a bit excessive to me. I'm going to walk cautiously away from this one :-)

lattner: I'm not sure who is changing this, but this whole "max iterations" thing is probably a bad idea.
do { do {
// Add all nested operations to the worklist. assert(worklist.empty() &&
"Each iteration should start with empty worklist");
// Add all nested operations to the worklist in preorder.
for (auto &region : regions) for (auto &region : regions)
region.walk(collectOps); region.walk<WalkOrder::PreOrder>(
[this](Operation *op) { worklist.push_back(op); });
// Reverse the list so our pop-back loop processes them in-order.
std::reverse(worklist.begin(), worklist.end());
// Remember the reverse index.
for (unsigned i = 0, e = worklist.size(); i != e; ++i)
worklistMap[worklist[i]] = i;
bondhugulaUnsubmitted
Done
ReplyInline Actions

Instead of adding them in pre-order and reversing, what happens if used post order while iterating over the ops of each block in reverse? Even for pre-order, we could have an option to traverse the ops of a block in reverse so that the contents of the vector won't have to be moved around later?

bondhugula: Instead of adding them in pre-order and reversing, what happens if used post order while…
lattnerAuthorUnsubmitted
Done
ReplyInline Actions

I don't think that the microoptimization will do anything to help performance, and I like the simplicity of the code. It is very clear and direct.

lattner: I don't think that the microoptimization will do anything to help performance, and I like the…
// These are scratch vectors used in the folding loop below. // These are scratch vectors used in the folding loop below.
SmallVector<Value, 8> originalOperands, resultValues; SmallVector<Value, 8> originalOperands, resultValues;
changed = false; changed = false;
while (!worklist.empty()) { while (!worklist.empty()) {
auto *op = popFromWorklist(); auto *op = popFromWorklist();
// Nulls get added to the worklist when operations are removed, ignore // Nulls get added to the worklist when operations are removed, ignore
Show All 20 Lines while (!worklist.empty()) {
// to revisit them. // to revisit them.
for (auto result : op->getResults()) for (auto result : op->getResults())
for (auto *userOp : result.getUsers()) for (auto *userOp : result.getUsers())
addToWorklist(userOp); addToWorklist(userOp);
notifyOperationRemoved(op); notifyOperationRemoved(op);
}; };
// Add the given operation to the worklist.
auto collectOps = [this](Operation *op) { addToWorklist(op); };
// Try to fold this op. // Try to fold this op.
bool inPlaceUpdate; bool inPlaceUpdate;
if ((succeeded(folder.tryToFold(op, collectOps, preReplaceAction, if ((succeeded(folder.tryToFold(op, collectOps, preReplaceAction,
&inPlaceUpdate)))) { &inPlaceUpdate)))) {
changed = true; changed = true;
if (!inPlaceUpdate) if (!inPlaceUpdate)
continue; continue;
} }
// Try to match one of the patterns. The rewriter is automatically // Try to match one of the patterns. The rewriter is automatically
// notified of any necessary changes, so there is nothing else to do here. // notified of any necessary changes, so there is nothing else to do here.
changed |= succeeded(matcher.matchAndRewrite(op, *this)); changed |= succeeded(matcher.matchAndRewrite(op, *this));
} }
// After applying patterns, make sure that the CFG of each of the regions is // After applying patterns, make sure that the CFG of each of the regions is
// kept up to date. // kept up to date.
if (succeeded(simplifyRegions(regions))) { if (succeeded(simplifyRegions(regions))) {
folder.clear(); folder.clear();
changed = true; changed = true;
} }
} while (changed && ++i < maxIterations); } while (changed && ++iteration < maxIterations);
// Whether the rewrite converges, i.e. wasn't changed in the last iteration. // Whether the rewrite converges, i.e. wasn't changed in the last iteration.
return !changed; return !changed;
} }
/// Rewrite the regions of the specified operation, which must be isolated from /// Rewrite the regions of the specified operation, which must be isolated from
/// above, by repeatedly applying the highest benefit patterns in a greedy /// above, by repeatedly applying the highest benefit patterns in a greedy
/// work-list driven manner. Return success if no more patterns can be matched /// work-list driven manner. Return success if no more patterns can be matched
/// in the result operation regions. Note: This does not apply patterns to the /// in the result operation regions. Note: This does not apply patterns to the
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

mlir/test/Conversion/StandardToSPIRV/legalization.mlir

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Linesfunc @fold_dynamic_stride_subview_with_store(%arg0 : memref<12x32xf32>, %arg1 : index, %arg2 : index, %arg3 : index, %arg4 : index, %arg5 : index, %arg6 : index, %arg7 : f32) {
store %arg7, %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [?, ?]> store %arg7, %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [?, ?]>
return return
} }
// CHECK-LABEL: @fold_static_stride_subview_with_transfer_read // CHECK-LABEL: @fold_static_stride_subview_with_transfer_read
// CHECK-SAME: [[ARG0:%.*]]: memref<12x32xf32>, [[ARG1:%.*]]: index, [[ARG2:%.*]]: index, [[ARG3:%.*]]: index, [[ARG4:%.*]]: index // CHECK-SAME: [[ARG0:%.*]]: memref<12x32xf32>, [[ARG1:%.*]]: index, [[ARG2:%.*]]: index, [[ARG3:%.*]]: index, [[ARG4:%.*]]: index
func @fold_static_stride_subview_with_transfer_read(%arg0 : memref<12x32xf32>, %arg1 : index, %arg2 : index, %arg3 : index, %arg4 : index) -> vector<4xf32> { func @fold_static_stride_subview_with_transfer_read(%arg0 : memref<12x32xf32>, %arg1 : index, %arg2 : index, %arg3 : index, %arg4 : index) -> vector<4xf32> {
// CHECK-NOT: subview // CHECK-NOT: subview
// CHECK: [[F1:%.*]] = constant 1.000000e+00 : f32
// CHECK: [[C2:%.*]] = constant 2 : index // CHECK: [[C2:%.*]] = constant 2 : index
// CHECK: [[C3:%.*]] = constant 3 : index // CHECK: [[C3:%.*]] = constant 3 : index
// CHECK: [[F1:%.*]] = constant 1.000000e+00 : f32
// CHECK: [[STRIDE1:%.*]] = muli [[ARG3]], [[C2]] : index // CHECK: [[STRIDE1:%.*]] = muli [[ARG3]], [[C2]] : index
// CHECK: [[INDEX1:%.*]] = addi [[ARG1]], [[STRIDE1]] : index // CHECK: [[INDEX1:%.*]] = addi [[ARG1]], [[STRIDE1]] : index
// CHECK: [[STRIDE2:%.*]] = muli [[ARG4]], [[C3]] : index // CHECK: [[STRIDE2:%.*]] = muli [[ARG4]], [[C3]] : index
// CHECK: [[INDEX2:%.*]] = addi [[ARG2]], [[STRIDE2]] : index // CHECK: [[INDEX2:%.*]] = addi [[ARG2]], [[STRIDE2]] : index
// CHECK: vector.transfer_read [[ARG0]]{{\[}}[[INDEX1]], [[INDEX2]]{{\]}}, [[F1]] {masked = [false]} // CHECK: vector.transfer_read [[ARG0]]{{\[}}[[INDEX1]], [[INDEX2]]{{\]}}, [[F1]] {masked = [false]}
%f1 = constant 1.0 : f32 %f1 = constant 1.0 : f32
%0 = subview %arg0[%arg1, %arg2][4, 4][2, 3] : memref<12x32xf32> to memref<4x4xf32, offset:?, strides: [64, 3]> %0 = subview %arg0[%arg1, %arg2][4, 4][2, 3] : memref<12x32xf32> to memref<4x4xf32, offset:?, strides: [64, 3]>
%1 = vector.transfer_read %0[%arg3, %arg4], %f1 {masked = [false]} : memref<4x4xf32, offset:?, strides: [64, 3]>, vector<4xf32> %1 = vector.transfer_read %0[%arg3, %arg4], %f1 {masked = [false]} : memref<4x4xf32, offset:?, strides: [64, 3]>, vector<4xf32>
Show All 19 Lines

mlir/test/Conversion/VectorToSCF/vector-to-loops.mlir

Show First 20 Lines • Show All 194 Lines • ▼ Show 20 Lines
// CHECK-SAME: %[[A:[a-zA-Z0-9]+]]: memref<?x?xf32>, // CHECK-SAME: %[[A:[a-zA-Z0-9]+]]: memref<?x?xf32>,
// CHECK-SAME: %[[base:[a-zA-Z0-9]+]]: index // CHECK-SAME: %[[base:[a-zA-Z0-9]+]]: index
// FULL-UNROLL-LABEL: transfer_read_progressive( // FULL-UNROLL-LABEL: transfer_read_progressive(
// FULL-UNROLL-SAME: %[[A:[a-zA-Z0-9]+]]: memref<?x?xf32>, // FULL-UNROLL-SAME: %[[A:[a-zA-Z0-9]+]]: memref<?x?xf32>,
// FULL-UNROLL-SAME: %[[base:[a-zA-Z0-9]+]]: index // FULL-UNROLL-SAME: %[[base:[a-zA-Z0-9]+]]: index
func @transfer_read_progressive(%A : memref<?x?xf32>, %base: index) -> vector<3x15xf32> { func @transfer_read_progressive(%A : memref<?x?xf32>, %base: index) -> vector<3x15xf32> {
// CHECK: %[[cst:.*]] = constant 7.000000e+00 : f32
%f7 = constant 7.0: f32 %f7 = constant 7.0: f32
// CHECK-DAG: %[[C0:.*]] = constant 0 : index
// CHECK-DAG: %[[splat:.*]] = constant dense<7.000000e+00> : vector<15xf32> // CHECK-DAG: %[[splat:.*]] = constant dense<7.000000e+00> : vector<15xf32>
// CHECK-DAG: %[[alloc:.*]] = alloca() : memref<3xvector<15xf32>> // CHECK-DAG: %[[alloc:.*]] = alloca() : memref<3xvector<15xf32>>
// CHECK-DAG: %[[C0:.*]] = constant 0 : index // CHECK: %[[cst:.*]] = constant 7.000000e+00 : f32
// CHECK-DAG: %[[dim:.*]] = dim %[[A]], %[[C0]] : memref<?x?xf32> // CHECK-DAG: %[[dim:.*]] = dim %[[A]], %[[C0]] : memref<?x?xf32>
// CHECK: affine.for %[[I:.*]] = 0 to 3 { // 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: %[[cond1:.*]] = cmpi slt, %[[add]], %[[dim]] : index
// CHECK: scf.if %[[cond1]] { // CHECK: scf.if %[[cond1]] {
// CHECK: %[[vec_1d:.*]] = vector.transfer_read %[[A]][%[[add]], %[[base]]], %[[cst]] : memref<?x?xf32>, vector<15xf32> // CHECK: %[[vec_1d:.*]] = vector.transfer_read %[[A]][%[[add]], %[[base]]], %[[cst]] : memref<?x?xf32>, vector<15xf32>
// CHECK: store %[[vec_1d]], %[[alloc]][%[[I]]] : memref<3xvector<15xf32>> // CHECK: store %[[vec_1d]], %[[alloc]][%[[I]]] : memref<3xvector<15xf32>>
// CHECK: } else { // CHECK: } else {
// CHECK: store %[[splat]], %[[alloc]][%[[I]]] : memref<3xvector<15xf32>> // CHECK: store %[[splat]], %[[alloc]][%[[I]]] : memref<3xvector<15xf32>>
// CHECK: } // CHECK: }
// CHECK: %[[vmemref:.*]] = vector.type_cast %[[alloc]] : memref<3xvector<15xf32>> to memref<vector<3x15xf32>> // CHECK: %[[vmemref:.*]] = vector.type_cast %[[alloc]] : memref<3xvector<15xf32>> to memref<vector<3x15xf32>>
// CHECK: %[[cst:.*]] = load %[[vmemref]][] : memref<vector<3x15xf32>> // CHECK: %[[cst:.*]] = load %[[vmemref]][] : memref<vector<3x15xf32>>
// FULL-UNROLL: %[[pad:.*]] = constant 7.000000e+00 : f32
// FULL-UNROLL: %[[VEC0:.*]] = constant dense<7.000000e+00> : vector<3x15xf32> // FULL-UNROLL: %[[VEC0:.*]] = constant dense<7.000000e+00> : vector<3x15xf32>
// FULL-UNROLL: %[[C0:.*]] = constant 0 : index // FULL-UNROLL: %[[C0:.*]] = constant 0 : index
// FULL-UNROLL: %[[SPLAT:.*]] = constant dense<7.000000e+00> : vector<15xf32> // FULL-UNROLL: %[[SPLAT:.*]] = constant dense<7.000000e+00> : vector<15xf32>
// FULL-UNROLL: %[[pad:.*]] = constant 7.000000e+00 : f32
// FULL-UNROLL: %[[DIM:.*]] = dim %[[A]], %[[C0]] : memref<?x?xf32> // FULL-UNROLL: %[[DIM:.*]] = dim %[[A]], %[[C0]] : memref<?x?xf32>
// FULL-UNROLL: cmpi slt, %[[base]], %[[DIM]] : index // FULL-UNROLL: cmpi slt, %[[base]], %[[DIM]] : index
// FULL-UNROLL: %[[VEC1:.*]] = scf.if %{{.*}} -> (vector<3x15xf32>) { // FULL-UNROLL: %[[VEC1:.*]] = scf.if %{{.*}} -> (vector<3x15xf32>) {
// FULL-UNROLL: vector.transfer_read %[[A]][%[[base]], %[[base]]], %[[pad]] : memref<?x?xf32>, vector<15xf32> // FULL-UNROLL: vector.transfer_read %[[A]][%[[base]], %[[base]]], %[[pad]] : memref<?x?xf32>, vector<15xf32>
// FULL-UNROLL: vector.insert %{{.*}}, %[[VEC0]] [0] : vector<15xf32> into vector<3x15xf32> // FULL-UNROLL: vector.insert %{{.*}}, %[[VEC0]] [0] : vector<15xf32> into vector<3x15xf32>
// FULL-UNROLL: scf.yield %{{.*}} : vector<3x15xf32> // FULL-UNROLL: scf.yield %{{.*}} : vector<3x15xf32>
// FULL-UNROLL: } else { // FULL-UNROLL: } else {
// FULL-UNROLL: vector.insert %{{.*}}, %[[VEC0]] [0] : vector<15xf32> into vector<3x15xf32> // FULL-UNROLL: vector.insert %{{.*}}, %[[VEC0]] [0] : vector<15xf32> into vector<3x15xf32>
▲ Show 20 Lines • Show All 141 Lines • ▼ Show 20 Linesfunc @transfer_read_minor_identity(%A : memref<?x?x?x?xf32>) -> vector<3x3xf32> {
%0 = vector.transfer_read %A[%c0, %c0, %c0, %c0], %f0 %0 = vector.transfer_read %A[%c0, %c0, %c0, %c0], %f0
{ permutation_map = affine_map<(d0, d1, d2, d3) -> (d2, d3)> } { permutation_map = affine_map<(d0, d1, d2, d3) -> (d2, d3)> }
: memref<?x?x?x?xf32>, vector<3x3xf32> : memref<?x?x?x?xf32>, vector<3x3xf32>
return %0 : vector<3x3xf32> return %0 : vector<3x3xf32>
} }
// CHECK-LABEL: transfer_read_minor_identity( // CHECK-LABEL: transfer_read_minor_identity(
// CHECK-SAME: %[[A:.*]]: memref<?x?x?x?xf32>) -> vector<3x3xf32> // CHECK-SAME: %[[A:.*]]: memref<?x?x?x?xf32>) -> vector<3x3xf32>
// CHECK: %[[c0:.*]] = constant 0 : index
// CHECK: %[[cst:.*]] = constant 0.000000e+00 : f32
// CHECK: %[[c2:.*]] = constant 2 : index // CHECK: %[[c2:.*]] = constant 2 : index
// CHECK: %[[cst0:.*]] = constant dense<0.000000e+00> : vector<3xf32> // CHECK: %[[cst0:.*]] = constant dense<0.000000e+00> : vector<3xf32>
// CHECK: %[[m:.*]] = alloca() : memref<3xvector<3xf32>> // CHECK: %[[m:.*]] = alloca() : memref<3xvector<3xf32>>
// CHECK: %[[c0:.*]] = constant 0 : index
// CHECK: %[[cst:.*]] = constant 0.000000e+00 : f32
// CHECK: %[[d:.*]] = dim %[[A]], %[[c2]] : memref<?x?x?x?xf32> // CHECK: %[[d:.*]] = dim %[[A]], %[[c2]] : memref<?x?x?x?xf32>
// CHECK: affine.for %[[arg1:.*]] = 0 to 3 { // CHECK: affine.for %[[arg1:.*]] = 0 to 3 {
// CHECK: %[[cmp:.*]] = cmpi slt, %[[arg1]], %[[d]] : index // CHECK: %[[cmp:.*]] = cmpi slt, %[[arg1]], %[[d]] : index
// CHECK: scf.if %[[cmp]] { // CHECK: scf.if %[[cmp]] {
// CHECK: %[[tr:.*]] = vector.transfer_read %[[A]][%[[c0]], %[[c0]], %[[arg1]], %[[c0]]], %[[cst]] : memref<?x?x?x?xf32>, vector<3xf32> // CHECK: %[[tr:.*]] = vector.transfer_read %[[A]][%[[c0]], %[[c0]], %[[arg1]], %[[c0]]], %[[cst]] : memref<?x?x?x?xf32>, vector<3xf32>
// CHECK: store %[[tr]], %[[m]][%[[arg1]]] : memref<3xvector<3xf32>> // CHECK: store %[[tr]], %[[m]][%[[arg1]]] : memref<3xvector<3xf32>>
// CHECK: } else { // CHECK: } else {
// CHECK: store %[[cst0]], %[[m]][%[[arg1]]] : memref<3xvector<3xf32>> // CHECK: store %[[cst0]], %[[m]][%[[arg1]]] : memref<3xvector<3xf32>>
Show All 10 Lines vector.transfer_write %A, %B[%c0, %c0, %c0, %c0]
{ permutation_map = affine_map<(d0, d1, d2, d3) -> (d2, d3)> } { permutation_map = affine_map<(d0, d1, d2, d3) -> (d2, d3)> }
: vector<3x3xf32>, memref<?x?x?x?xf32> : vector<3x3xf32>, memref<?x?x?x?xf32>
return return
} }
// CHECK-LABEL: transfer_write_minor_identity( // CHECK-LABEL: transfer_write_minor_identity(
// CHECK-SAME: %[[A:.*]]: vector<3x3xf32>, // CHECK-SAME: %[[A:.*]]: vector<3x3xf32>,
// CHECK-SAME: %[[B:.*]]: memref<?x?x?x?xf32>) // CHECK-SAME: %[[B:.*]]: memref<?x?x?x?xf32>)
// CHECK: %[[c0:.*]] = constant 0 : index
// CHECK: %[[c2:.*]] = constant 2 : index // CHECK: %[[c2:.*]] = constant 2 : index
// CHECK: %[[m:.*]] = alloca() : memref<3xvector<3xf32>> // CHECK: %[[m:.*]] = alloca() : memref<3xvector<3xf32>>
// CHECK: %[[c0:.*]] = constant 0 : index
// CHECK: %[[cast:.*]] = vector.type_cast %[[m]] : memref<3xvector<3xf32>> to memref<vector<3x3xf32>> // CHECK: %[[cast:.*]] = vector.type_cast %[[m]] : memref<3xvector<3xf32>> to memref<vector<3x3xf32>>
// CHECK: store %[[A]], %[[cast]][] : memref<vector<3x3xf32>> // CHECK: store %[[A]], %[[cast]][] : memref<vector<3x3xf32>>
// CHECK: %[[d:.*]] = dim %[[B]], %[[c2]] : memref<?x?x?x?xf32> // CHECK: %[[d:.*]] = dim %[[B]], %[[c2]] : memref<?x?x?x?xf32>
// CHECK: affine.for %[[arg2:.*]] = 0 to 3 { // CHECK: affine.for %[[arg2:.*]] = 0 to 3 {
// CHECK: %[[cmp:.*]] = cmpi slt, %[[arg2]], %[[d]] : index // CHECK: %[[cmp:.*]] = cmpi slt, %[[arg2]], %[[d]] : index
// CHECK: scf.if %[[cmp]] { // CHECK: scf.if %[[cmp]] {
// CHECK: %[[tmp:.*]] = load %[[m]][%[[arg2]]] : memref<3xvector<3xf32>> // CHECK: %[[tmp:.*]] = load %[[m]][%[[arg2]]] : memref<3xvector<3xf32>>
// CHECK: vector.transfer_write %[[tmp]], %[[B]][%[[c0]], %[[c0]], %[[arg2]], %[[c0]]] : vector<3xf32>, memref<?x?x?x?xf32> // CHECK: vector.transfer_write %[[tmp]], %[[B]][%[[c0]], %[[c0]], %[[arg2]], %[[c0]]] : vector<3xf32>, memref<?x?x?x?xf32>
Show All 28 Lines

mlir/test/Dialect/Affine/canonicalize.mlir

Show First 20 Lines • Show All 201 Lines • ▼ Show 20 Lines affine.for %i0 = 0 to 15 {
store %arg0, %arg1[%d0, %d1] : memref<4x4xf32> store %arg0, %arg1[%d0, %d1] : memref<4x4xf32>
} }
return return
} }
// ----- // -----
// CHECK-DAG: #[[$MAP14:.*]] = affine_map<()[s0, s1] -> (((s1 + s0) * 4) floordiv s0)> // CHECK-DAG: #[[$MAP14:.*]] = affine_map<()[s0, s1] -> ((s0 * 4 + s1 * 4) floordiv s0)>
// CHECK-LABEL: func @compose_affine_maps_multiple_symbols // CHECK-LABEL: func @compose_affine_maps_multiple_symbols
func @compose_affine_maps_multiple_symbols(%arg0: index, %arg1: index) -> index { func @compose_affine_maps_multiple_symbols(%arg0: index, %arg1: index) -> index {
%a = affine.apply affine_map<(d0)[s0] -> (s0 + d0)> (%arg0)[%arg1] %a = affine.apply affine_map<(d0)[s0] -> (s0 + d0)> (%arg0)[%arg1]
%c = affine.apply affine_map<(d0) -> (d0 * 4)> (%a) %c = affine.apply affine_map<(d0) -> (d0 * 4)> (%a)
%e = affine.apply affine_map<(d0)[s0] -> (d0 floordiv s0)> (%c)[%arg1] %e = affine.apply affine_map<(d0)[s0] -> (d0 floordiv s0)> (%c)[%arg1]
// CHECK: [[I0:.*]] = affine.apply #[[$MAP14]]()[%{{.*}}, %{{.*}}] // CHECK: [[I0:.*]] = affine.apply #[[$MAP14]]()[%{{.*}}, %{{.*}}]
return %e : index return %e : index
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Linesfunc @symbolic_composition_c(%arg0: index, %arg1: index, %arg2: index, %arg3: index) -> index {
%1 = affine.apply affine_map<(d0) -> (d0)>(%arg1) %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] %2 = affine.apply affine_map<()[s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)>()[%0, %0, %0, %1]
// CHECK: %{{.*}} = affine.apply #[[$MAP_symbolic_composition_c]]()[%{{.*}}, %{{.*}}] // CHECK: %{{.*}} = affine.apply #[[$MAP_symbolic_composition_c]]()[%{{.*}}, %{{.*}}]
return %2 : index return %2 : index
} }
// ----- // -----
// CHECK-DAG: #[[$MAP_symbolic_composition_d:.*]] = affine_map<()[s0, s1] -> (s0 + s1 * 3)> // CHECK-DAG: #[[$MAP_symbolic_composition_d:.*]] = affine_map<()[s0, s1] -> (s0 * 3 + s1)>
// CHECK-LABEL: func @symbolic_composition_d( // CHECK-LABEL: func @symbolic_composition_d(
// CHECK-SAME: %[[ARG0:[0-9a-zA-Z]+]]: index // CHECK-SAME: %[[ARG0:[0-9a-zA-Z]+]]: index
// CHECK-SAME: %[[ARG1:[0-9a-zA-Z]+]]: index // CHECK-SAME: %[[ARG1:[0-9a-zA-Z]+]]: index
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) %0 = affine.apply affine_map<(d0) -> (d0)>(%arg0)
%1 = affine.apply affine_map<()[s0] -> (s0)>()[%arg1] %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] %2 = affine.apply affine_map<()[s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)>()[%0, %0, %0, %1]
// CHECK: %{{.*}} = affine.apply #[[$MAP_symbolic_composition_d]]()[%[[ARG1]], %[[ARG0]]] // CHECK: %{{.*}} = affine.apply #[[$MAP_symbolic_composition_d]]()[%[[ARG0]], %[[ARG1]]]
return %2 : index return %2 : index
} }
// ----- // -----
// CHECK-DAG: #[[$MAP_mix_dims_and_symbols_b:.*]] = affine_map<()[s0, s1] -> (s0 * 42 + s1 + 6)> // CHECK-DAG: #[[$MAP_mix_dims_and_symbols_b:.*]] = affine_map<()[s0, s1] -> (s0 * 42 + s1 + 6)>
// CHECK-LABEL: func @mix_dims_and_symbols_b(%arg0: index, %arg1: index) -> index { // CHECK-LABEL: func @mix_dims_and_symbols_b(%arg0: index, %arg1: index) -> index {
▲ Show 20 Lines • Show All 364 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/sparse_2d.mlir

Show First 20 Lines • Show All 1,157 Lines • ▼ Show 20 Lines#trait_scale = {
], ],
iterator_types = ["parallel", "parallel"], iterator_types = ["parallel", "parallel"],
doc = "X(i,j) = A(i,j) * SCALE" doc = "X(i,j) = A(i,j) * SCALE"
} }
// CHECK-LABEL: func @scale( // CHECK-LABEL: func @scale(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<?x?xf64>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<?x?xf64>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<?x?xf64>) -> tensor<?x?xf64> { // CHECK-SAME: %[[VAL_1:.*]]: tensor<?x?xf64>) -> tensor<?x?xf64> {
// CHECK: %[[VAL_2:.*]] = constant 2.000000e+00 : f64
// CHECK: %[[VAL_3:.*]] = constant 0 : index // CHECK: %[[VAL_3:.*]] = constant 0 : index
// CHECK: %[[VAL_4:.*]] = constant 1 : index // CHECK: %[[VAL_4:.*]] = constant 1 : index
// CHECK: %[[VAL_2:.*]] = constant 2.000000e+00 : f64
// CHECK: %[[VAL_5:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_4]] : tensor<?x?xf64> to memref<?xindex> // CHECK: %[[VAL_5:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_4]] : tensor<?x?xf64> to memref<?xindex>
// CHECK: %[[VAL_6:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<?x?xf64> to memref<?xindex> // CHECK: %[[VAL_6:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<?x?xf64> to memref<?xindex>
// CHECK: %[[VAL_7:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<?x?xf64> to memref<?xf64> // CHECK: %[[VAL_7:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<?x?xf64> to memref<?xf64>
// CHECK: %[[VAL_8:.*]] = dim %[[VAL_1]], %[[VAL_3]] : tensor<?x?xf64> // CHECK: %[[VAL_8:.*]] = dim %[[VAL_1]], %[[VAL_3]] : tensor<?x?xf64>
// CHECK: %[[VAL_9:.*]] = dim %[[VAL_1]], %[[VAL_4]] : tensor<?x?xf64> // CHECK: %[[VAL_9:.*]] = dim %[[VAL_1]], %[[VAL_4]] : tensor<?x?xf64>
// CHECK: %[[VAL_10:.*]] = tensor_to_memref %[[VAL_1]] : memref<?x?xf64> // CHECK: %[[VAL_10:.*]] = tensor_to_memref %[[VAL_1]] : memref<?x?xf64>
// CHECK: %[[VAL_11:.*]] = alloc(%[[VAL_8]], %[[VAL_9]]) : memref<?x?xf64> // CHECK: %[[VAL_11:.*]] = alloc(%[[VAL_8]], %[[VAL_9]]) : memref<?x?xf64>
// CHECK: linalg.copy(%[[VAL_10]], %[[VAL_11]]) : memref<?x?xf64>, memref<?x?xf64> // CHECK: linalg.copy(%[[VAL_10]], %[[VAL_11]]) : memref<?x?xf64>, memref<?x?xf64>
▲ Show 20 Lines • Show All 338 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/transform-patterns.mlir

Show First 20 Lines • Show All 330 Lines • ▼ Show 20 Linesfunc @aligned_promote_fill(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>) {
%cf = constant 1.0 : f32 %cf = constant 1.0 : f32
%3 = std.subview %arg0[%c0, %c0][%c2000, %c4000][%c1, %c1] : %3 = std.subview %arg0[%c0, %c0][%c2000, %c4000][%c1, %c1] :
memref<?x?xf32, offset: ?, strides: [?, 1]> to memref<?x?xf32, offset: ?, strides: [?, ?]> memref<?x?xf32, offset: ?, strides: [?, 1]> to memref<?x?xf32, offset: ?, strides: [?, ?]>
linalg.fill(%3, %cf) { __internal_linalg_transform__ = "_promote_views_aligned_"} linalg.fill(%3, %cf) { __internal_linalg_transform__ = "_promote_views_aligned_"}
: memref<?x?xf32, offset: ?, strides: [?, ?]>, f32 : memref<?x?xf32, offset: ?, strides: [?, ?]>, f32
return return
} }
// CHECK-LABEL: func @aligned_promote_fill // CHECK-LABEL: func @aligned_promote_fill
// CHECK: %[[cf:.*]] = constant {{.*}} : f32 // CHECK: %[[cf:.*]] = constant 1.0{{.*}} : f32
// CHECK: %[[s0:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}> // CHECK: %[[s0:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
// CHECK: %[[a0:.*]] = alloc({{%.*}}) {alignment = 32 : i64} : memref<?xi8> // CHECK: %[[a0:.*]] = alloc({{%.*}}) {alignment = 32 : i64} : memref<?xi8>
// CHECK: %[[v0:.*]] = std.view %[[a0]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32> // CHECK: %[[v0:.*]] = std.view %[[a0]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
// CHECK: %[[l0:.*]] = subview %[[v0]][0, 0] [%{{.*}}, %{{.*}}] [1, 1] : memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D_u_1]]> // CHECK: %[[l0:.*]] = subview %[[v0]][0, 0] [%{{.*}}, %{{.*}}] [1, 1] : memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D_u_1]]>
// CHECK: linalg.fill(%[[v0]], {{%.*}}) : memref<?x?xf32>, f32 // CHECK: linalg.fill(%[[v0]], {{%.*}}) : memref<?x?xf32>, f32
// CHECK: linalg.copy(%[[s0]], %[[l0]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}> // CHECK: linalg.copy(%[[s0]], %[[l0]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
// CHECK: linalg.fill(%[[v0]], %[[cf]]) : memref<?x?xf32>, f32 // CHECK: linalg.fill(%[[v0]], %[[cf]]) : memref<?x?xf32>, f32
Show All 22 Lines

mlir/test/Dialect/Quant/convert-const.mlir

Show First 20 Lines • Show All 138 Lines • ▼ Show 20 Linesfunc @const_custom_storage_range_i8_fixedpoint() -> tensor<7xf32> {
return %2 : tensor<7xf32> return %2 : tensor<7xf32>
} }
// ----- // -----
// Verifies quantization results of all-0.0 tensors are quantized to zero points. // Verifies quantization results of all-0.0 tensors are quantized to zero points.
// CHECK-LABEL: zero_tensors_to_zero_points // CHECK-LABEL: zero_tensors_to_zero_points
func @zero_tensors_to_zero_points() -> (tensor<7xf32>, tensor<7xf32>, tensor<7xf32>, tensor<7xf32>) { func @zero_tensors_to_zero_points() -> (tensor<7xf32>, tensor<7xf32>, tensor<7xf32>, tensor<7xf32>) {
// CHECK: %[[cst1:.*]] = constant dense<1> : tensor<7xi8>
// CHECK: %[[cst:.*]] = constant dense<-127> : tensor<7xi8> // CHECK: %[[cst:.*]] = constant dense<-127> : tensor<7xi8>
// CHECK: %[[cst0:.*]] = constant dense<0> : tensor<7xi8> // CHECK: %[[cst0:.*]] = constant dense<0> : tensor<7xi8>
// CHECK: %[[cst1:.*]] = constant dense<1> : tensor<7xi8>
// CHECK: "quant.scast"(%[[cst0]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<i8:f32, 1.000000e+00>> // CHECK: "quant.scast"(%[[cst0]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<i8:f32, 1.000000e+00>>
// CHECK: "quant.scast"(%[[cst]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<i8<-127:127>:f32, 1.000000e+00:-127>> // CHECK: "quant.scast"(%[[cst]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<i8<-127:127>:f32, 1.000000e+00:-127>>
// CHECK: "quant.scast"(%[[cst0]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<u8:f32, 1.000000e+00>> // CHECK: "quant.scast"(%[[cst0]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<u8:f32, 1.000000e+00>>
// CHECK: "quant.scast"(%[[cst1]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<u8<1:255>:f32, 1.000000e+00:1>> // CHECK: "quant.scast"(%[[cst1]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<u8<1:255>:f32, 1.000000e+00:1>>
%cst = constant dense<0.0> : tensor<7xf32> %cst = constant dense<0.0> : tensor<7xf32>
%1 = "quant.qcast"(%cst) : (tensor<7xf32>) -> tensor<7x!quant.uniform<i8:f32, 1.0>> %1 = "quant.qcast"(%cst) : (tensor<7xf32>) -> tensor<7x!quant.uniform<i8:f32, 1.0>>
%2 = "quant.dcast"(%1) : (tensor<7x!quant.uniform<i8:f32, 1.0>>) -> (tensor<7xf32>) %2 = "quant.dcast"(%1) : (tensor<7x!quant.uniform<i8:f32, 1.0>>) -> (tensor<7xf32>)
Show All 13 Lines// CHECK: "quant.scast"(%[[cst1]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<u8<1:255>:f32, 1.000000e+00:1>>
return %2, %4, %6, %8 : tensor<7xf32>, tensor<7xf32>, tensor<7xf32>, tensor<7xf32> return %2, %4, %6, %8 : tensor<7xf32>, tensor<7xf32>, tensor<7xf32>, tensor<7xf32>
} }
// ----- // -----
// Verifies per-axis quantization results for dense. // Verifies per-axis quantization results for dense.
// CHECK-LABEL: per_axis_dense_quantization // CHECK-LABEL: per_axis_dense_quantization
func @per_axis_dense_quantization() -> (tensor<2x3xf32>, tensor<2x3xf32>) { func @per_axis_dense_quantization() -> (tensor<2x3xf32>, tensor<2x3xf32>) {
// CHECK-NEXT: %[[cst:.*]] = constant dense<{{\[}}[-128, 64, 127], [0, 1, 2]]> : tensor<2x3xi8>
// CHECK-NEXT: %[[cst0:.*]] = constant dense<{{\[}}[-128, -1, 1], [127, 1, 3]]> : tensor<2x3xi8> // CHECK-NEXT: %[[cst0:.*]] = constant dense<{{\[}}[-128, -1, 1], [127, 1, 3]]> : tensor<2x3xi8>
// CHECK-NEXT: %[[cst:.*]] = constant dense<{{\[}}[-128, 64, 127], [0, 1, 2]]> : tensor<2x3xi8>
// CHECK: "quant.scast"(%[[cst]]) : (tensor<2x3xi8>) -> tensor<2x3x!quant.uniform<i8:f32:0, {7.812500e-03:128,1.000000e+00}>> // CHECK: "quant.scast"(%[[cst]]) : (tensor<2x3xi8>) -> tensor<2x3x!quant.uniform<i8:f32:0, {7.812500e-03:128,1.000000e+00}>>
// CHECK: "quant.scast"(%cst_0) : (tensor<2x3xi8>) -> tensor<2x3x!quant.uniform<i8:f32:1, {7.812500e-03:128,1.000000e+00,1.000000e+00:1}>> // CHECK: "quant.scast"(%[[cst0]]) : (tensor<2x3xi8>) -> tensor<2x3x!quant.uniform<i8:f32:1, {7.812500e-03:128,1.000000e+00,1.000000e+00:1}>>
%cst = constant dense<[[-2.0, -0.5, 0.0], [0.0, 1.0, 2.0]]> : tensor<2x3xf32> %cst = constant dense<[[-2.0, -0.5, 0.0], [0.0, 1.0, 2.0]]> : tensor<2x3xf32>
%1 = "quant.qcast"(%cst) : (tensor<2x3xf32>) -> tensor<2x3x!quant.uniform<i8:f32:0, {7.812500e-03:128, 1.0}>> %1 = "quant.qcast"(%cst) : (tensor<2x3xf32>) -> tensor<2x3x!quant.uniform<i8:f32:0, {7.812500e-03:128, 1.0}>>
%2 = "quant.dcast"(%1) : (tensor<2x3x!quant.uniform<i8:f32:0, {7.812500e-03:128, 1.0}>>) -> (tensor<2x3xf32>) %2 = "quant.dcast"(%1) : (tensor<2x3x!quant.uniform<i8:f32:0, {7.812500e-03:128, 1.0}>>) -> (tensor<2x3xf32>)
%cst0 = constant dense<[[-2.0, -0.5, 0.0], [0.0, 1.0, 2.0]]> : tensor<2x3xf32> %cst0 = constant dense<[[-2.0, -0.5, 0.0], [0.0, 1.0, 2.0]]> : tensor<2x3xf32>
%3 = "quant.qcast"(%cst0) : (tensor<2x3xf32>) -> tensor<2x3x!quant.uniform<i8:f32:1, {7.812500e-03:128, 1.0, 1.0:1}>> %3 = "quant.qcast"(%cst0) : (tensor<2x3xf32>) -> tensor<2x3x!quant.uniform<i8:f32:1, {7.812500e-03:128, 1.0, 1.0:1}>>
%4 = "quant.dcast"(%3) : (tensor<2x3x!quant.uniform<i8:f32:1, {7.812500e-03:128, 1.0, 1.0:1}>>) -> (tensor<2x3xf32>) %4 = "quant.dcast"(%3) : (tensor<2x3x!quant.uniform<i8:f32:1, {7.812500e-03:128, 1.0, 1.0:1}>>) -> (tensor<2x3xf32>)
return %2, %4 : tensor<2x3xf32>, tensor<2x3xf32> return %2, %4 : tensor<2x3xf32>, tensor<2x3xf32>
} }

mlir/test/Dialect/SCF/canonicalize.mlir

Show All 15 Lines scf.parallel (%i0, %i1, %i2) = (%c0, %c3, %c7) to (%c1, %c6, %c10) step (%c1, %c2, %c3) {
store %c42, %A[%i0, %i1, %i2] : memref<?x?x?xi32> store %c42, %A[%i0, %i1, %i2] : memref<?x?x?xi32>
scf.yield scf.yield
} }
return return
} }
// CHECK-LABEL: func @single_iteration( // CHECK-LABEL: func @single_iteration(
// CHECK-SAME: [[ARG0:%.*]]: memref<?x?x?xi32>) { // CHECK-SAME: [[ARG0:%.*]]: memref<?x?x?xi32>) {
// CHECK: [[C0:%.*]] = constant 0 : index
// CHECK: [[C2:%.*]] = constant 2 : index
// CHECK: [[C3:%.*]] = constant 3 : index
// CHECK: [[C6:%.*]] = constant 6 : index
// CHECK: [[C7:%.*]] = constant 7 : index
// CHECK: [[C42:%.*]] = constant 42 : i32 // CHECK: [[C42:%.*]] = constant 42 : i32
// CHECK: [[C7:%.*]] = constant 7 : index
// CHECK: [[C6:%.*]] = constant 6 : index
// CHECK: [[C3:%.*]] = constant 3 : index
// CHECK: [[C2:%.*]] = constant 2 : index
// CHECK: [[C0:%.*]] = constant 0 : index
// CHECK: scf.parallel ([[V0:%.*]]) = ([[C3]]) to ([[C6]]) step ([[C2]]) { // CHECK: scf.parallel ([[V0:%.*]]) = ([[C3]]) to ([[C6]]) step ([[C2]]) {
// CHECK: store [[C42]], [[ARG0]]{{\[}}[[C0]], [[V0]], [[C7]]] : memref<?x?x?xi32> // CHECK: store [[C42]], [[ARG0]]{{\[}}[[C0]], [[V0]], [[C7]]] : memref<?x?x?xi32>
// CHECK: scf.yield // CHECK: scf.yield
// CHECK: } // CHECK: }
// CHECK: return // CHECK: return
// ----- // -----
▲ Show 20 Lines • Show All 347 Lines • Show Last 20 Lines

mlir/test/Dialect/SPIRV/Transforms/canonicalize.mlir

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.CompositeExtract // spv.CompositeExtract
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: extract_vector // CHECK-LABEL: extract_vector
func @extract_vector() -> (i32, i32, i32) { func @extract_vector() -> (i32, i32, i32) {
// CHECK: spv.Constant 42 : i32
// CHECK: spv.Constant -33 : i32
// CHECK: spv.Constant 6 : i32 // CHECK: spv.Constant 6 : i32
// CHECK: spv.Constant -33 : i32
// CHECK: spv.Constant 42 : i32
%0 = spv.Constant dense<[42, -33, 6]> : vector<3xi32> %0 = spv.Constant dense<[42, -33, 6]> : vector<3xi32>
%1 = spv.CompositeExtract %0[0 : i32] : vector<3xi32> %1 = spv.CompositeExtract %0[0 : i32] : vector<3xi32>
%2 = spv.CompositeExtract %0[1 : i32] : vector<3xi32> %2 = spv.CompositeExtract %0[1 : i32] : vector<3xi32>
%3 = spv.CompositeExtract %0[2 : i32] : vector<3xi32> %3 = spv.CompositeExtract %0[2 : i32] : vector<3xi32>
return %1, %2, %3 : i32, i32, i32 return %1, %2, %3 : i32, i32, i32
} }
// ----- // -----
// CHECK-LABEL: extract_array_final // CHECK-LABEL: extract_array_final
func @extract_array_final() -> (i32, i32) { func @extract_array_final() -> (i32, i32) {
// CHECK: spv.Constant 4 : i32
// CHECK: spv.Constant -5 : i32 // CHECK: spv.Constant -5 : i32
// CHECK: spv.Constant 4 : i32
%0 = spv.Constant [dense<[4, -5]> : vector<2xi32>] : !spv.array<1 x vector<2xi32>> %0 = spv.Constant [dense<[4, -5]> : vector<2xi32>] : !spv.array<1 x vector<2xi32>>
%1 = spv.CompositeExtract %0[0 : i32, 0 : i32] : !spv.array<1 x vector<2 x i32>> %1 = spv.CompositeExtract %0[0 : i32, 0 : i32] : !spv.array<1 x vector<2 x i32>>
%2 = spv.CompositeExtract %0[0 : i32, 1 : i32] : !spv.array<1 x vector<2 x i32>> %2 = spv.CompositeExtract %0[0 : i32, 1 : i32] : !spv.array<1 x vector<2 x i32>>
return %1, %2 : i32, i32 return %1, %2 : i32, i32
} }
// ----- // -----
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Linesfunc @iadd_zero(%arg0: i32) -> (i32, i32) {
return %0, %1: i32, i32 return %0, %1: i32, i32
} }
// CHECK-LABEL: @const_fold_scalar_iadd_normal // CHECK-LABEL: @const_fold_scalar_iadd_normal
func @const_fold_scalar_iadd_normal() -> (i32, i32, i32) { func @const_fold_scalar_iadd_normal() -> (i32, i32, i32) {
%c5 = spv.Constant 5 : i32 %c5 = spv.Constant 5 : i32
%cn8 = spv.Constant -8 : i32 %cn8 = spv.Constant -8 : i32
// CHECK: spv.Constant 10
// CHECK: spv.Constant -16
// CHECK: spv.Constant -3 // CHECK: spv.Constant -3
// CHECK: spv.Constant -16
// CHECK: spv.Constant 10
%0 = spv.IAdd %c5, %c5 : i32 %0 = spv.IAdd %c5, %c5 : i32
%1 = spv.IAdd %cn8, %cn8 : i32 %1 = spv.IAdd %cn8, %cn8 : i32
%2 = spv.IAdd %c5, %cn8 : i32 %2 = spv.IAdd %c5, %cn8 : i32
return %0, %1, %2: i32, i32, i32 return %0, %1, %2: i32, i32, i32
} }
// CHECK-LABEL: @const_fold_scalar_iadd_flow // CHECK-LABEL: @const_fold_scalar_iadd_flow
func @const_fold_scalar_iadd_flow() -> (i32, i32, i32, i32) { func @const_fold_scalar_iadd_flow() -> (i32, i32, i32, i32) {
%c1 = spv.Constant 1 : i32 %c1 = spv.Constant 1 : i32
%c2 = spv.Constant 2 : i32 %c2 = spv.Constant 2 : i32
%c3 = spv.Constant 4294967295 : i32 // 2^32 - 1: 0xffff ffff %c3 = spv.Constant 4294967295 : i32 // 2^32 - 1: 0xffff ffff
%c4 = spv.Constant -2147483648 : i32 // -2^31 : 0x8000 0000 %c4 = spv.Constant -2147483648 : i32 // -2^31 : 0x8000 0000
%c5 = spv.Constant -1 : i32 // : 0xffff ffff %c5 = spv.Constant -1 : i32 // : 0xffff ffff
%c6 = spv.Constant -2 : i32 // : 0xffff fffe %c6 = spv.Constant -2 : i32 // : 0xffff fffe
// 0x8000 0000 + 0xffff fffe = 0x1 7fff fffe -> 0x7fff fffe
// CHECK: spv.Constant 2147483646
// 0x8000 0000 + 0xffff ffff = 0x1 7fff ffff -> 0x7fff ffff
// CHECK: spv.Constant 2147483647
// 0x0000 0002 + 0xffff ffff = 0x1 0000 0001 -> 0x0000 0001
// CHECK: spv.Constant 1
// 0x0000 0001 + 0xffff ffff = 0x1 0000 0000 -> 0x0000 0000 // 0x0000 0001 + 0xffff ffff = 0x1 0000 0000 -> 0x0000 0000
// CHECK: spv.Constant 0 // CHECK: spv.Constant 0
%0 = spv.IAdd %c1, %c3 : i32 %0 = spv.IAdd %c1, %c3 : i32
// 0x0000 0002 + 0xffff ffff = 0x1 0000 0001 -> 0x0000 0001
// CHECK: spv.Constant 1
%1 = spv.IAdd %c2, %c3 : i32 %1 = spv.IAdd %c2, %c3 : i32
// 0x8000 0000 + 0xffff ffff = 0x1 7fff ffff -> 0x7fff ffff
// CHECK: spv.Constant 2147483647
%2 = spv.IAdd %c4, %c5 : i32 %2 = spv.IAdd %c4, %c5 : i32
// 0x8000 0000 + 0xffff fffe = 0x1 7fff fffe -> 0x7fff fffe
// CHECK: spv.Constant 2147483646
%3 = spv.IAdd %c4, %c6 : i32 %3 = spv.IAdd %c4, %c6 : i32
return %0, %1, %2, %3: i32, i32, i32, i32 return %0, %1, %2, %3: i32, i32, i32, i32
} }
// CHECK-LABEL: @const_fold_vector_iadd // CHECK-LABEL: @const_fold_vector_iadd
func @const_fold_vector_iadd() -> vector<3xi32> { func @const_fold_vector_iadd() -> vector<3xi32> {
%vc1 = spv.Constant dense<[42, -55, 127]> : vector<3xi32> %vc1 = spv.Constant dense<[42, -55, 127]> : vector<3xi32>
%vc2 = spv.Constant dense<[-3, -15, 28]> : vector<3xi32> %vc2 = spv.Constant dense<[-3, -15, 28]> : vector<3xi32>
Show All 22 Lines
} }
// CHECK-LABEL: @const_fold_scalar_imul_normal // CHECK-LABEL: @const_fold_scalar_imul_normal
func @const_fold_scalar_imul_normal() -> (i32, i32, i32) { func @const_fold_scalar_imul_normal() -> (i32, i32, i32) {
%c5 = spv.Constant 5 : i32 %c5 = spv.Constant 5 : i32
%cn8 = spv.Constant -8 : i32 %cn8 = spv.Constant -8 : i32
%c7 = spv.Constant 7 : i32 %c7 = spv.Constant 7 : i32
// CHECK: spv.Constant 35
// CHECK: spv.Constant -40
// CHECK: spv.Constant -56 // CHECK: spv.Constant -56
// CHECK: spv.Constant -40
// CHECK: spv.Constant 35
%0 = spv.IMul %c7, %c5 : i32 %0 = spv.IMul %c7, %c5 : i32
%1 = spv.IMul %c5, %cn8 : i32 %1 = spv.IMul %c5, %cn8 : i32
%2 = spv.IMul %cn8, %c7 : i32 %2 = spv.IMul %cn8, %c7 : i32
return %0, %1, %2: i32, i32, i32 return %0, %1, %2: i32, i32, i32
} }
// CHECK-LABEL: @const_fold_scalar_imul_flow // CHECK-LABEL: @const_fold_scalar_imul_flow
func @const_fold_scalar_imul_flow() -> (i32, i32, i32) { func @const_fold_scalar_imul_flow() -> (i32, i32, i32) {
%c1 = spv.Constant 2 : i32 %c1 = spv.Constant 2 : i32
%c2 = spv.Constant 4 : i32 %c2 = spv.Constant 4 : i32
%c3 = spv.Constant 4294967295 : i32 // 2^32 - 1 : 0xffff ffff %c3 = spv.Constant 4294967295 : i32 // 2^32 - 1 : 0xffff ffff
%c4 = spv.Constant 2147483647 : i32 // 2^31 - 1 : 0x7fff ffff %c4 = spv.Constant 2147483647 : i32 // 2^31 - 1 : 0x7fff ffff
// (0x7fff ffff << 2) = 0x1 ffff fffc -> 0xffff fffc
// CHECK: %[[CST4:.*]] = spv.Constant -4
// (0xffff ffff << 1) = 0x1 ffff fffe -> 0xffff fffe // (0xffff ffff << 1) = 0x1 ffff fffe -> 0xffff fffe
// CHECK: %[[CST2:.*]] = spv.Constant -2 // CHECK: %[[CST2:.*]] = spv.Constant -2
%0 = spv.IMul %c1, %c3 : i32 %0 = spv.IMul %c1, %c3 : i32
// (0x7fff ffff << 1) = 0x0 ffff fffe -> 0xffff fffe // (0x7fff ffff << 1) = 0x0 ffff fffe -> 0xffff fffe
%1 = spv.IMul %c1, %c4 : i32 %1 = spv.IMul %c1, %c4 : i32
// (0x7fff ffff << 2) = 0x1 ffff fffc -> 0xffff fffc
// CHECK: %[[CST4:.*]] = spv.Constant -4
%2 = spv.IMul %c4, %c2 : i32 %2 = spv.IMul %c4, %c2 : i32
// CHECK: return %[[CST2]], %[[CST2]], %[[CST4]] // CHECK: return %[[CST2]], %[[CST2]], %[[CST4]]
return %0, %1, %2: i32, i32, i32 return %0, %1, %2: i32, i32, i32
} }
// CHECK-LABEL: @const_fold_vector_imul // CHECK-LABEL: @const_fold_vector_imul
func @const_fold_vector_imul() -> vector<3xi32> { func @const_fold_vector_imul() -> vector<3xi32> {
Show All 19 Lines
} }
// CHECK-LABEL: @const_fold_scalar_isub_normal // CHECK-LABEL: @const_fold_scalar_isub_normal
func @const_fold_scalar_isub_normal() -> (i32, i32, i32) { func @const_fold_scalar_isub_normal() -> (i32, i32, i32) {
%c5 = spv.Constant 5 : i32 %c5 = spv.Constant 5 : i32
%cn8 = spv.Constant -8 : i32 %cn8 = spv.Constant -8 : i32
%c7 = spv.Constant 7 : i32 %c7 = spv.Constant 7 : i32
// CHECK: spv.Constant 2
// CHECK: spv.Constant 13
// CHECK: spv.Constant -15 // CHECK: spv.Constant -15
// CHECK: spv.Constant 13
// CHECK: spv.Constant 2
%0 = spv.ISub %c7, %c5 : i32 %0 = spv.ISub %c7, %c5 : i32
%1 = spv.ISub %c5, %cn8 : i32 %1 = spv.ISub %c5, %cn8 : i32
%2 = spv.ISub %cn8, %c7 : i32 %2 = spv.ISub %cn8, %c7 : i32
return %0, %1, %2: i32, i32, i32 return %0, %1, %2: i32, i32, i32
} }
// CHECK-LABEL: @const_fold_scalar_isub_flow // CHECK-LABEL: @const_fold_scalar_isub_flow
func @const_fold_scalar_isub_flow() -> (i32, i32, i32, i32) { func @const_fold_scalar_isub_flow() -> (i32, i32, i32, i32) {
%c1 = spv.Constant 0 : i32 %c1 = spv.Constant 0 : i32
%c2 = spv.Constant 1 : i32 %c2 = spv.Constant 1 : i32
%c3 = spv.Constant 4294967295 : i32 // 2^32 - 1 : 0xffff ffff %c3 = spv.Constant 4294967295 : i32 // 2^32 - 1 : 0xffff ffff
%c4 = spv.Constant 2147483647 : i32 // 2^31 : 0x7fff ffff %c4 = spv.Constant 2147483647 : i32 // 2^31 : 0x7fff ffff
%c5 = spv.Constant -1 : i32 // : 0xffff ffff %c5 = spv.Constant -1 : i32 // : 0xffff ffff
%c6 = spv.Constant -2 : i32 // : 0xffff fffe %c6 = spv.Constant -2 : i32 // : 0xffff fffe
// 0xffff ffff - 0x7fff ffff -> 0xffff ffff + 0x8000 0001 = 0x1 8000 0000
// CHECK: spv.Constant -2147483648
// 0x0000 0001 - 0xffff ffff -> 0x0000 0001 + 0x0000 0001 = 0x0000 0002
// CHECK: spv.Constant 2
// 0x0000 0000 - 0xffff ffff -> 0x0000 0000 + 0x0000 0001 = 0x0000 0001 // 0x0000 0000 - 0xffff ffff -> 0x0000 0000 + 0x0000 0001 = 0x0000 0001
// CHECK: spv.Constant 1 // CHECK: spv.Constant 1
// 0xffff fffe - 0x7fff ffff -> 0xffff fffe + 0x8000 0001 = 0x1 7fff ffff
// CHECK: spv.Constant 2147483647
%0 = spv.ISub %c1, %c3 : i32 %0 = spv.ISub %c1, %c3 : i32
// 0x0000 0001 - 0xffff ffff -> 0x0000 0001 + 0x0000 0001 = 0x0000 0002
// CHECK: spv.Constant 2
%1 = spv.ISub %c2, %c3 : i32 %1 = spv.ISub %c2, %c3 : i32
// 0xffff ffff - 0x7fff ffff -> 0xffff ffff + 0x8000 0001 = 0x1 8000 0000
// CHECK: spv.Constant -2147483648
%2 = spv.ISub %c5, %c4 : i32 %2 = spv.ISub %c5, %c4 : i32
// 0xffff fffe - 0x7fff ffff -> 0xffff fffe + 0x8000 0001 = 0x1 7fff ffff
// CHECK: spv.Constant 2147483647
%3 = spv.ISub %c6, %c4 : i32 %3 = spv.ISub %c6, %c4 : i32
return %0, %1, %2, %3: i32, i32, i32, i32 return %0, %1, %2, %3: i32, i32, i32, i32
} }
// CHECK-LABEL: @const_fold_vector_isub // CHECK-LABEL: @const_fold_vector_isub
func @const_fold_vector_isub() -> vector<3xi32> { func @const_fold_vector_isub() -> vector<3xi32> {
%vc1 = spv.Constant dense<[42, -55, 127]> : vector<3xi32> %vc1 = spv.Constant dense<[42, -55, 127]> : vector<3xi32>
%vc2 = spv.Constant dense<[-3, -15, 28]> : vector<3xi32> %vc2 = spv.Constant dense<[-3, -15, 28]> : vector<3xi32>
▲ Show 20 Lines • Show All 183 Lines • ▼ Show 20 Linesfunc @canonicalize_selection_op_vector_type(%cond: i1) -> () {
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
// ----- // -----
// CHECK-LABEL: cannot_canonicalize_selection_op_0
// Store to a different variables. // Store to a different variables.
func @cannot_canonicalize_selection_op_0(%cond: i1) -> () { func @cannot_canonicalize_selection_op_0(%cond: i1) -> () {
%0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32> %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32> // CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
%1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32> %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
%2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32> %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
// CHECK: %[[DST_VAR_0:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function> // CHECK: %[[DST_VAR_0:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
%3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function> %3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function>
// CHECK: %[[DST_VAR_1:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function> // CHECK: %[[DST_VAR_1:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
%4 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function> %4 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function>
// CHECK: spv.mlir.selection { // CHECK: spv.mlir.selection {
spv.mlir.selection { spv.mlir.selection {
Show All 15 Linesfunc @cannot_canonicalize_selection_op_0(%cond: i1) -> () {
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
// ----- // -----
// CHECK-LABEL: cannot_canonicalize_selection_op_1
// A conditional block consists of more than 2 operations. // A conditional block consists of more than 2 operations.
func @cannot_canonicalize_selection_op_1(%cond: i1) -> () { func @cannot_canonicalize_selection_op_1(%cond: i1) -> () {
%0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32> %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32> // CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
%1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32> %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32> // CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
%2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32> %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
// CHECK: %[[DST_VAR_0:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function> // CHECK: %[[DST_VAR_0:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
Show All 20 Linesfunc @cannot_canonicalize_selection_op_1(%cond: i1) -> () {
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
// ----- // -----
// CHECK-LABEL: cannot_canonicalize_selection_op_2
// A control-flow goes into `^then` block from `^else` block. // A control-flow goes into `^then` block from `^else` block.
func @cannot_canonicalize_selection_op_2(%cond: i1) -> () { func @cannot_canonicalize_selection_op_2(%cond: i1) -> () {
%0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32> %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32> // CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
%1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32> %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32> // CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
%2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32> %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
// CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function> // CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
Show All 16 Linesfunc @cannot_canonicalize_selection_op_2(%cond: i1) -> () {
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
// ----- // -----
// CHECK-LABEL: cannot_canonicalize_selection_op_3
// `spv.Return` as a block terminator. // `spv.Return` as a block terminator.
func @cannot_canonicalize_selection_op_3(%cond: i1) -> () { func @cannot_canonicalize_selection_op_3(%cond: i1) -> () {
%0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32> %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
%1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32> %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32> // CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
%2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32> %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
// CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function> // CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
%3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function> %3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function>
// CHECK: spv.mlir.selection { // CHECK: spv.mlir.selection {
spv.mlir.selection { spv.mlir.selection {
spv.BranchConditional %cond, ^then, ^else spv.BranchConditional %cond, ^then, ^else
Show All 11 Linesfunc @cannot_canonicalize_selection_op_3(%cond: i1) -> () {
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
// ----- // -----
// CHECK-LABEL: cannot_canonicalize_selection_op_4
// Different memory access attributes. // Different memory access attributes.
func @cannot_canonicalize_selection_op_4(%cond: i1) -> () { func @cannot_canonicalize_selection_op_4(%cond: i1) -> () {
%0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32> %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32> // CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
%1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32> %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32> // CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
%2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32> %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
// CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function> // CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
Show All 21 Lines

mlir/test/Dialect/Tensor/canonicalize.mlir

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
// ----- // -----
// CHECK-LABEL: func @fold_extract // CHECK-LABEL: func @fold_extract
func @fold_extract(%arg0 : index) -> (f32, f16, f16, i32) { func @fold_extract(%arg0 : index) -> (f32, f16, f16, i32) {
%const_0 = constant 0 : index %const_0 = constant 0 : index
%const_1 = constant 1 : index %const_1 = constant 1 : index
%const_3 = constant 3 : index %const_3 = constant 3 : index
// CHECK-NEXT: [[C64:%.+]] = constant 64 : i32
// CHECK-NEXT: [[C0:%.+]] = constant 0.{{0*}}e+00 : f16
// CHECK-NEXT: [[CM2:%.+]] = constant -2.{{0*}}e+00 : f16
// Fold an extract into a splat. // Fold an extract into a splat.
// CHECK-NEXT: [[C4:%.+]] = constant 4.{{0*}}e+00 : f32 // CHECK-NEXT: [[C4:%.+]] = constant 4.{{0*}}e+00 : f32
%0 = constant dense<4.0> : tensor<4xf32> %0 = constant dense<4.0> : tensor<4xf32>
%ext_1 = tensor.extract %0[%arg0] : tensor<4xf32> %ext_1 = tensor.extract %0[%arg0] : tensor<4xf32>
// Fold an extract into a sparse with a sparse index. // Fold an extract into a sparse with a sparse index.
// CHECK-NEXT: [[CM2:%.+]] = constant -2.{{0*}}e+00 : f16
%1 = constant sparse<[[0, 0, 0], [1, 1, 1]], [-5.0, -2.0]> : tensor<4x4x4xf16> %1 = constant sparse<[[0, 0, 0], [1, 1, 1]], [-5.0, -2.0]> : tensor<4x4x4xf16>
%ext_2 = tensor.extract %1[%const_1, %const_1, %const_1] : tensor<4x4x4xf16> %ext_2 = tensor.extract %1[%const_1, %const_1, %const_1] : tensor<4x4x4xf16>
// Fold an extract into a sparse with a non sparse index. // Fold an extract into a sparse with a non sparse index.
// CHECK-NEXT: [[C0:%.+]] = constant 0.{{0*}}e+00 : f16
%2 = constant sparse<[[1, 1, 1]], [-2.0]> : tensor<1x1x1xf16> %2 = constant sparse<[[1, 1, 1]], [-2.0]> : tensor<1x1x1xf16>
%ext_3 = tensor.extract %2[%const_0, %const_0, %const_0] : tensor<1x1x1xf16> %ext_3 = tensor.extract %2[%const_0, %const_0, %const_0] : tensor<1x1x1xf16>
// Fold an extract into a dense tensor. // Fold an extract into a dense tensor.
// CHECK-NEXT: [[C64:%.+]] = constant 64 : i32
%3 = constant dense<[[[1, -2, 1, 36]], [[0, 2, -1, 64]]]> : tensor<2x1x4xi32> %3 = constant dense<[[[1, -2, 1, 36]], [[0, 2, -1, 64]]]> : tensor<2x1x4xi32>
%ext_4 = tensor.extract %3[%const_1, %const_0, %const_3] : tensor<2x1x4xi32> %ext_4 = tensor.extract %3[%const_1, %const_0, %const_3] : tensor<2x1x4xi32>
// CHECK-NEXT: return [[C4]], [[CM2]], [[C0]], [[C64]] // CHECK-NEXT: return [[C4]], [[CM2]], [[C0]], [[C64]]
return %ext_1, %ext_2, %ext_3, %ext_4 : f32, f16, f16, i32 return %ext_1, %ext_2, %ext_3, %ext_4 : f32, f16, f16, i32
} }
// ----- // -----
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines

mlir/test/Dialect/Vector/canonicalize.mlir

Show First 20 Lines • Show All 228 Lines • ▼ Show 20 Lines
// ----- // -----
// CHECK-LABEL: transpose_3D_sequence // CHECK-LABEL: transpose_3D_sequence
// CHECK-SAME: ([[ARG:%.*]]: vector<4x3x2xf32>) // CHECK-SAME: ([[ARG:%.*]]: vector<4x3x2xf32>)
func @transpose_3D_sequence(%arg : vector<4x3x2xf32>) -> vector<4x3x2xf32> { func @transpose_3D_sequence(%arg : vector<4x3x2xf32>) -> vector<4x3x2xf32> {
// CHECK: [[T0:%.*]] = vector.transpose [[ARG]], [2, 1, 0] // CHECK: [[T0:%.*]] = vector.transpose [[ARG]], [2, 1, 0]
%0 = vector.transpose %arg, [1, 2, 0] : vector<4x3x2xf32> to vector<3x2x4xf32> %0 = vector.transpose %arg, [1, 2, 0] : vector<4x3x2xf32> to vector<3x2x4xf32>
%1 = vector.transpose %0, [1, 0, 2] : vector<3x2x4xf32> to vector<2x3x4xf32> %1 = vector.transpose %0, [1, 0, 2] : vector<3x2x4xf32> to vector<2x3x4xf32>
// CHECK-NOT: transpose // CHECK: [[T1:%.*]] = vector.transpose [[ARG]], [2, 1, 0]
%2 = vector.transpose %1, [2, 1, 0] : vector<2x3x4xf32> to vector<4x3x2xf32> %2 = vector.transpose %1, [2, 1, 0] : vector<2x3x4xf32> to vector<4x3x2xf32>
%3 = vector.transpose %2, [2, 1, 0] : vector<4x3x2xf32> to vector<2x3x4xf32> %3 = vector.transpose %2, [2, 1, 0] : vector<4x3x2xf32> to vector<2x3x4xf32>
// CHECK: [[MUL:%.*]] = mulf [[T0]], [[T0]] // CHECK: [[MUL:%.*]] = mulf [[T0]], [[T1]]
%4 = mulf %1, %3 : vector<2x3x4xf32> %4 = mulf %1, %3 : vector<2x3x4xf32>
// CHECK: [[T5:%.*]] = vector.transpose [[MUL]], [2, 1, 0] // CHECK: [[T5:%.*]] = vector.transpose [[MUL]], [2, 1, 0]
%5 = vector.transpose %4, [2, 1, 0] : vector<2x3x4xf32> to vector<4x3x2xf32> %5 = vector.transpose %4, [2, 1, 0] : vector<2x3x4xf32> to vector<4x3x2xf32>
// CHECK-NOT: transpose // CHECK-NOT: transpose
%6 = vector.transpose %3, [2, 1, 0] : vector<2x3x4xf32> to vector<4x3x2xf32> %6 = vector.transpose %3, [2, 1, 0] : vector<2x3x4xf32> to vector<4x3x2xf32>
// CHECK: [[ADD:%.*]] = addf [[T5]], [[ARG]] // CHECK: [[ADD:%.*]] = addf [[T5]], [[ARG]]
%7 = addf %5, %6 : vector<4x3x2xf32> %7 = addf %5, %6 : vector<4x3x2xf32>
// CHECK-NEXT: return [[ADD]] // CHECK-NEXT: return [[ADD]]
▲ Show 20 Lines • Show All 317 Lines • ▼ Show 20 Lines
func @bitcast_folding(%I1: vector<4x8xf32>, %I2: vector<2xi32>) -> (vector<4x8xf32>, vector<2xi32>) { func @bitcast_folding(%I1: vector<4x8xf32>, %I2: vector<2xi32>) -> (vector<4x8xf32>, vector<2xi32>) {
%0 = vector.bitcast %I1 : vector<4x8xf32> to vector<4x8xf32> %0 = vector.bitcast %I1 : vector<4x8xf32> to vector<4x8xf32>
%1 = vector.bitcast %I2 : vector<2xi32> to vector<4xi16> %1 = vector.bitcast %I2 : vector<2xi32> to vector<4xi16>
%2 = vector.bitcast %1 : vector<4xi16> to vector<2xi32> %2 = vector.bitcast %1 : vector<4xi16> to vector<2xi32>
return %0, %2 : vector<4x8xf32>, vector<2xi32> return %0, %2 : vector<4x8xf32>, vector<2xi32>
} }
// CHECK-LABEL: func @bitcast_f16_to_f32 // CHECK-LABEL: func @bitcast_f16_to_f32
// bit pattern: 0x00000000
// CHECK: %[[CST0:.+]] = constant dense<0.000000e+00> : vector<4xf32>
// bit pattern: 0x40004000 // bit pattern: 0x40004000
// CHECK: %[[CST1:.+]] = constant dense<2.00390625> : vector<4xf32> // CHECK: %[[CST1:.+]] = constant dense<2.00390625> : vector<4xf32>
// bit pattern: 0x00000000
// CHECK: %[[CST0:.+]] = constant dense<0.000000e+00> : vector<4xf32>
// CHECK: return %[[CST0]], %[[CST1]] // CHECK: return %[[CST0]], %[[CST1]]
func @bitcast_f16_to_f32() -> (vector<4xf32>, vector<4xf32>) { func @bitcast_f16_to_f32() -> (vector<4xf32>, vector<4xf32>) {
%cst0 = constant dense<0.0> : vector<8xf16> // bit pattern: 0x0000 %cst0 = constant dense<0.0> : vector<8xf16> // bit pattern: 0x0000
%cst1 = constant dense<2.0> : vector<8xf16> // bit pattern: 0x4000 %cst1 = constant dense<2.0> : vector<8xf16> // bit pattern: 0x4000
%cast0 = vector.bitcast %cst0: vector<8xf16> to vector<4xf32> %cast0 = vector.bitcast %cst0: vector<8xf16> to vector<4xf32>
%cast1 = vector.bitcast %cst1: vector<8xf16> to vector<4xf32> %cast1 = vector.bitcast %cst1: vector<8xf16> to vector<4xf32>
return %cast0, %cast1: vector<4xf32>, vector<4xf32> return %cast0, %cast1: vector<4xf32>, vector<4xf32>
} }
Show All 21 Linesfunc @broadcast_folding2() -> vector<4x16xi32> {
%1 = vector.broadcast %0 : i32 to vector<16xi32> %1 = vector.broadcast %0 : i32 to vector<16xi32>
%2 = vector.broadcast %1 : vector<16xi32> to vector<4x16xi32> %2 = vector.broadcast %1 : vector<16xi32> to vector<4x16xi32>
return %2 : vector<4x16xi32> return %2 : vector<4x16xi32>
} }
// ----- // -----
// CHECK-LABEL: shape_cast_constant // CHECK-LABEL: shape_cast_constant
// CHECK: %[[CST0:.*]] = constant dense<2.000000e+00> : vector<20x2xf32>
// CHECK: %[[CST1:.*]] = constant dense<1> : vector<3x4x2xi32> // CHECK: %[[CST1:.*]] = constant dense<1> : vector<3x4x2xi32>
// CHECK: %[[CST0:.*]] = constant dense<2.000000e+00> : vector<20x2xf32>
// CHECK: return %[[CST0]], %[[CST1]] : vector<20x2xf32>, vector<3x4x2xi32> // CHECK: return %[[CST0]], %[[CST1]] : vector<20x2xf32>, vector<3x4x2xi32>
func @shape_cast_constant() -> (vector<20x2xf32>, vector<3x4x2xi32>) { func @shape_cast_constant() -> (vector<20x2xf32>, vector<3x4x2xi32>) {
%cst = constant dense<2.000000e+00> : vector<5x4x2xf32> %cst = constant dense<2.000000e+00> : vector<5x4x2xf32>
%cst_1 = constant dense<1> : vector<12x2xi32> %cst_1 = constant dense<1> : vector<12x2xi32>
%0 = vector.shape_cast %cst : vector<5x4x2xf32> to vector<20x2xf32> %0 = vector.shape_cast %cst : vector<5x4x2xf32> to vector<20x2xf32>
%1 = vector.shape_cast %cst_1 : vector<12x2xi32> to vector<3x4x2xi32> %1 = vector.shape_cast %cst_1 : vector<12x2xi32> to vector<3x4x2xi32>
return %0, %1 : vector<20x2xf32>, vector<3x4x2xi32> return %0, %1 : vector<20x2xf32>, vector<3x4x2xi32>
} }
// ----- // -----
// CHECK-LABEL: extract_strided_constant // CHECK-LABEL: extract_strided_constant
// CHECK: %[[CST0:.*]] = constant dense<2.000000e+00> : vector<12x2xf32>
// CHECK: %[[CST1:.*]] = constant dense<1> : vector<2x13x3xi32> // CHECK: %[[CST1:.*]] = constant dense<1> : vector<2x13x3xi32>
// CHECK: %[[CST0:.*]] = constant dense<2.000000e+00> : vector<12x2xf32>
// CHECK: return %[[CST0]], %[[CST1]] : vector<12x2xf32>, vector<2x13x3xi32> // CHECK: return %[[CST0]], %[[CST1]] : vector<12x2xf32>, vector<2x13x3xi32>
func @extract_strided_constant() -> (vector<12x2xf32>, vector<2x13x3xi32>) { func @extract_strided_constant() -> (vector<12x2xf32>, vector<2x13x3xi32>) {
%cst = constant dense<2.000000e+00> : vector<29x7xf32> %cst = constant dense<2.000000e+00> : vector<29x7xf32>
%cst_1 = constant dense<1> : vector<4x37x9xi32> %cst_1 = constant dense<1> : vector<4x37x9xi32>
%0 = vector.extract_strided_slice %cst %0 = vector.extract_strided_slice %cst
{offsets = [2, 3], sizes = [12, 2], strides = [1, 1]} {offsets = [2, 3], sizes = [12, 2], strides = [1, 1]}
: vector<29x7xf32> to vector<12x2xf32> : vector<29x7xf32> to vector<12x2xf32>
%1 = vector.extract_strided_slice %cst_1 %1 = vector.extract_strided_slice %cst_1
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

mlir/test/Dialect/Vector/vector-contract-transforms.mlir

Show First 20 Lines • Show All 425 Lines • ▼ Show 20 Lines
// CHECK: return %[[A]] : vector<16xf32> // CHECK: return %[[A]] : vector<16xf32>
func @nop_shape_cast(%arg0: vector<16xf32>) -> vector<16xf32> { func @nop_shape_cast(%arg0: vector<16xf32>) -> vector<16xf32> {
%0 = vector.shape_cast %arg0 : vector<16xf32> to vector<16xf32> %0 = vector.shape_cast %arg0 : vector<16xf32> to vector<16xf32>
return %0 : vector<16xf32> return %0 : vector<16xf32>
} }
// CHECK-LABEL: func @cancel_shape_cast // CHECK-LABEL: func @cancel_shape_cast
// CHECK-SAME: %[[A:.*]]: vector<16xf32> // FIXME: PR49590
// CHECK: return %[[A]] : vector<16xf32> // HECK-SAME: %[[A:.*]]: vector<16xf32>
// HECK: return %[[A]] : vector<16xf32>
func @cancel_shape_cast(%arg0: vector<16xf32>) -> vector<16xf32> { func @cancel_shape_cast(%arg0: vector<16xf32>) -> vector<16xf32> {
%0 = vector.shape_cast %arg0 : vector<16xf32> to vector<4x4xf32> %0 = vector.shape_cast %arg0 : vector<16xf32> to vector<4x4xf32>
%1 = vector.shape_cast %0 : vector<4x4xf32> to vector<16xf32> %1 = vector.shape_cast %0 : vector<4x4xf32> to vector<16xf32>
return %1 : vector<16xf32> return %1 : vector<16xf32>
} }
// Shape up and downcasts for 2-D vectors, for supporting conversion to // Shape up and downcasts for 2-D vectors, for supporting conversion to
// llvm.matrix operations // llvm.matrix operations
// CHECK-LABEL: func @shape_casts // CHECK-LABEL: func @shape_casts
func @shape_casts(%a: vector<2x2xf32>) -> (vector<4xf32>, vector<2x2xf32>) { func @shape_casts(%a: vector<2x2xf32>) -> (vector<4xf32>, vector<2x2xf32>) {
// CHECK: %[[cst:.*]] = constant dense<0.000000e+00> : vector<4xf32>
// CHECK: %[[cst22:.*]] = constant dense<0.000000e+00> : vector<2x2xf32> // CHECK: %[[cst22:.*]] = constant dense<0.000000e+00> : vector<2x2xf32>
// CHECK: %[[cst:.*]] = constant dense<0.000000e+00> : vector<4xf32>
// CHECK: %[[ex0:.*]] = vector.extract %{{.*}}[0] : vector<2x2xf32> // CHECK: %[[ex0:.*]] = vector.extract %{{.*}}[0] : vector<2x2xf32>
// //
// CHECK: %[[in0:.*]] = vector.insert_strided_slice %[[ex0]], %[[cst]] // CHECK: %[[in0:.*]] = vector.insert_strided_slice %[[ex0]], %[[cst]]
// CHECK-SAME: {offsets = [0], strides = [1]} : vector<2xf32> into vector<4xf32> // CHECK-SAME: {offsets = [0], strides = [1]} : vector<2xf32> into vector<4xf32>
// //
// CHECK: %[[ex1:.*]] = vector.extract %{{.*}}[1] : vector<2x2xf32> // CHECK: %[[ex1:.*]] = vector.extract %{{.*}}[1] : vector<2x2xf32>
// //
// CHECK: %[[in2:.*]] = vector.insert_strided_slice %[[ex1]], %[[in0]] // CHECK: %[[in2:.*]] = vector.insert_strided_slice %[[ex1]], %[[in0]]
▲ Show 20 Lines • Show All 672 Lines • Show Last 20 Lines

mlir/test/Dialect/Vector/vector-flat-transforms.mlir

Show All 16 Lines
func @transpose44_44(%arg0: vector<4x4xf32>) -> vector<4x4xf32> { func @transpose44_44(%arg0: vector<4x4xf32>) -> vector<4x4xf32> {
%0 = vector.transpose %arg0, [1, 0] : vector<4x4xf32> to vector<4x4xf32> %0 = vector.transpose %arg0, [1, 0] : vector<4x4xf32> to vector<4x4xf32>
return %0 : vector<4x4xf32> return %0 : vector<4x4xf32>
} }
// Folds preceding shape cast as expected, // Folds preceding shape cast as expected,
// no following shape cast folding expected. // no following shape cast folding expected.
// //
// FIXME: PR49590 - shape_cast not stable.
//
// CHECK-LABEL: func @transpose16_44( // CHECK-LABEL: func @transpose16_44(
// CHECK-SAME: %[[A:.*]]: vector<16xf32> // CHECK-SAME: %[[A:.*]]: vector<16xf32>
// CHECK: %[[T0:.*]] = vector.flat_transpose %[[A]] {columns = 4 : i32, rows = 4 : i32} : vector<16xf32> -> vector<16xf32> // HECK: %[[T0:.*]] = vector.flat_transpose %[[A]] {columns = 4 : i32, rows = 4 : i32} : vector<16xf32> -> vector<16xf32>
// CHECK: %[[T1:.*]] = vector.extract_strided_slice %[[T0]] {offsets = [0], sizes = [4], strides = [1]} : vector<16xf32> to vector<4xf32> // HECK: %[[T1:.*]] = vector.extract_strided_slice %[[T0]] {offsets = [0], sizes = [4], strides = [1]} : vector<16xf32> to vector<4xf32>
// //
func @transpose16_44(%arg0: vector<16xf32>) -> vector<4x4xf32> { func @transpose16_44(%arg0: vector<16xf32>) -> vector<4x4xf32> {
%0 = vector.shape_cast %arg0 : vector<16xf32> to vector<4x4xf32> %0 = vector.shape_cast %arg0 : vector<16xf32> to vector<4x4xf32>
%1 = vector.transpose %0, [1, 0] : vector<4x4xf32> to vector<4x4xf32> %1 = vector.transpose %0, [1, 0] : vector<4x4xf32> to vector<4x4xf32>
return %1 : vector<4x4xf32> return %1 : vector<4x4xf32>
} }
// No preceding shape cast folding expected, // No preceding shape cast folding expected,
// but FAILS to fold following cast. // but FAILS to fold following cast.
// //
// CHECK-LABEL: func @transpose44_16( // CHECK-LABEL: func @transpose44_16(
// CHECK-SAME: %[[A:.*]]: vector<4x4xf32> // CHECK-SAME: %[[A:.*]]: vector<4x4xf32>
// CHECK: %[[T0:.*]] = vector.extract %[[A]][0] : vector<4x4xf32> // CHECK: %[[T0:.*]] = vector.extract %[[A]][0] : vector<4x4xf32>
// CHECK: %[[T8:.*]] = vector.flat_transpose %{{.*}} {columns = 4 : i32, rows = 4 : i32} : vector<16xf32> -> vector<16xf32> // CHECK: %[[T8:.*]] = vector.flat_transpose %{{.*}} {columns = 4 : i32, rows = 4 : i32} : vector<16xf32> -> vector<16xf32>
func @transpose44_16(%arg0: vector<4x4xf32>) -> vector<16xf32> { func @transpose44_16(%arg0: vector<4x4xf32>) -> vector<16xf32> {
%0 = vector.transpose %arg0, [1, 0] : vector<4x4xf32> to vector<4x4xf32> %0 = vector.transpose %arg0, [1, 0] : vector<4x4xf32> to vector<4x4xf32>
%1 = vector.shape_cast %0 : vector<4x4xf32> to vector<16xf32> %1 = vector.shape_cast %0 : vector<4x4xf32> to vector<16xf32>
return %1 : vector<16xf32> return %1 : vector<16xf32>
} }
// Folds preceding shape cast as expected, // Folds preceding shape cast as expected,
// but FAILS to fold following cast. // but FAILS to fold following cast.
// //
// FIXME: PR49590 - shape_cast not stable.
//
// CHECK-LABEL: func @transpose16_16( // CHECK-LABEL: func @transpose16_16(
// CHECK-SAME: %[[A:.*]]: vector<16xf32> // CHECK-SAME: %[[A:.*]]: vector<16xf32>
// CHECK: %[[T0:.*]] = vector.flat_transpose %[[A]] {columns = 4 : i32, rows = 4 : i32} : vector<16xf32> -> vector<16xf32> // HECK: %[[T0:.*]] = vector.flat_transpose %[[A]] {columns = 4 : i32, rows = 4 : i32} : vector<16xf32> -> vector<16xf32>
// //
func @transpose16_16(%arg0: vector<16xf32>) -> vector<16xf32> { func @transpose16_16(%arg0: vector<16xf32>) -> vector<16xf32> {
%0 = vector.shape_cast %arg0 : vector<16xf32> to vector<4x4xf32> %0 = vector.shape_cast %arg0 : vector<16xf32> to vector<4x4xf32>
%1 = vector.transpose %0, [1, 0] : vector<4x4xf32> to vector<4x4xf32> %1 = vector.transpose %0, [1, 0] : vector<4x4xf32> to vector<4x4xf32>
%2 = vector.shape_cast %1 : vector<4x4xf32> to vector<16xf32> %2 = vector.shape_cast %1 : vector<4x4xf32> to vector<16xf32>
return %2 : vector<16xf32> return %2 : vector<16xf32>
} }

mlir/test/Dialect/Vector/vector-transfer-full-partial-split.mlir

Show All 19 Lines
// LINALG-LABEL: split_vector_transfer_read_2d( // LINALG-LABEL: split_vector_transfer_read_2d(
// LINALG-SAME: %[[A:[a-zA-Z0-9]*]]: memref // LINALG-SAME: %[[A:[a-zA-Z0-9]*]]: memref
// LINALG-SAME: %[[i:[a-zA-Z0-9]*]]: index // LINALG-SAME: %[[i:[a-zA-Z0-9]*]]: index
// LINALG-SAME: %[[j:[a-zA-Z0-9]*]]: index // LINALG-SAME: %[[j:[a-zA-Z0-9]*]]: index
func @split_vector_transfer_read_2d(%A: memref<?x8xf32>, %i: index, %j: index) -> vector<4x8xf32> { func @split_vector_transfer_read_2d(%A: memref<?x8xf32>, %i: index, %j: index) -> vector<4x8xf32> {
%c0 = constant 0 : index %c0 = constant 0 : index
%f0 = constant 0.0 : f32 %f0 = constant 0.0 : f32
// CHECK-DAG: %[[c0:.*]] = constant 0 : index
// CHECK-DAG: %[[c8:.*]] = constant 8 : index // CHECK-DAG: %[[c8:.*]] = constant 8 : index
// CHECK-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32 // CHECK-DAG: %[[c0:.*]] = constant 0 : index
// alloca for boundary full tile // alloca for boundary full tile
// CHECK: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32> // CHECK: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32>
// CHECK-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32
// %i + 4 <= dim(%A, 0) // %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<?x8xf32> // CHECK: %[[d0:.*]] = dim %[[A]], %[[c0]] : memref<?x8xf32>
// CHECK: %[[cmp0:.*]] = cmpi sle, %[[idx0]], %[[d0]] : index // CHECK: %[[cmp0:.*]] = cmpi sle, %[[idx0]], %[[d0]] : index
// %j + 8 <= dim(%A, 1) // %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 // CHECK: %[[cmp1:.*]] = cmpi sle, %[[idx1]], %[[c8]] : index
// are both conds true // are both conds true
Show All 14 Linesfunc @split_vector_transfer_read_2d(%A: memref<?x8xf32>, %i: index, %j: index) -> vector<4x8xf32> {
// CHECK-SAME: memref<?x8xf32>, index, index // CHECK-SAME: memref<?x8xf32>, index, index
// CHECK: } // CHECK: }
// CHECK: %[[res:.*]] = vector.transfer_read %[[ifres]]#0[%[[ifres]]#1, %[[ifres]]#2], %[[cst]] // CHECK: %[[res:.*]] = vector.transfer_read %[[ifres]]#0[%[[ifres]]#1, %[[ifres]]#2], %[[cst]]
// CHECK_SAME: {masked = [false, false]} : memref<?x8xf32>, vector<4x8xf32> // CHECK_SAME: {masked = [false, false]} : memref<?x8xf32>, vector<4x8xf32>
// LINALG-DAG: %[[c0:.*]] = constant 0 : index // LINALG-DAG: %[[c0:.*]] = constant 0 : index
// LINALG-DAG: %[[c4:.*]] = constant 4 : index // LINALG-DAG: %[[c4:.*]] = constant 4 : index
// LINALG-DAG: %[[c8:.*]] = constant 8 : index // LINALG-DAG: %[[c8:.*]] = constant 8 : index
// LINALG-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32
// alloca for boundary full tile // alloca for boundary full tile
// LINALG: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32> // LINALG: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32>
// LINALG-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32
// %i + 4 <= dim(%A, 0) // %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<?x8xf32> // LINALG: %[[d0:.*]] = dim %[[A]], %[[c0]] : memref<?x8xf32>
// LINALG: %[[cmp0:.*]] = cmpi sle, %[[idx0]], %[[d0]] : index // LINALG: %[[cmp0:.*]] = cmpi sle, %[[idx0]], %[[d0]] : index
// %j + 8 <= dim(%A, 1) // %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 // LINALG: %[[cmp1:.*]] = cmpi sle, %[[idx1]], %[[c8]] : index
// are both conds true // are both conds true
Show All 33 Lines
// LINALG-SAME: %[[i:[a-zA-Z0-9]*]]: index // LINALG-SAME: %[[i:[a-zA-Z0-9]*]]: index
// LINALG-SAME: %[[j:[a-zA-Z0-9]*]]: index // LINALG-SAME: %[[j:[a-zA-Z0-9]*]]: index
func @split_vector_transfer_read_strided_2d( func @split_vector_transfer_read_strided_2d(
%A: memref<7x8xf32, offset:?, strides:[?, 1]>, %A: memref<7x8xf32, offset:?, strides:[?, 1]>,
%i: index, %j: index) -> vector<4x8xf32> { %i: index, %j: index) -> vector<4x8xf32> {
%c0 = constant 0 : index %c0 = constant 0 : index
%f0 = constant 0.0 : f32 %f0 = constant 0.0 : f32
// CHECK-DAG: %[[c0:.*]] = constant 0 : index
// CHECK-DAG: %[[c7:.*]] = constant 7 : index // CHECK-DAG: %[[c7:.*]] = constant 7 : index
// CHECK-DAG: %[[c8:.*]] = constant 8 : index // CHECK-DAG: %[[c8:.*]] = constant 8 : index
// CHECK-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32 // CHECK-DAG: %[[c0:.*]] = constant 0 : index
// alloca for boundary full tile // alloca for boundary full tile
// CHECK: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32> // CHECK: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32>
// CHECK-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32
// %i + 4 <= dim(%A, 0) // %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 // CHECK: %[[cmp0:.*]] = cmpi sle, %[[idx0]], %[[c7]] : index
// %j + 8 <= dim(%A, 1) // %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 // CHECK: %[[cmp1:.*]] = cmpi sle, %[[idx1]], %[[c8]] : index
// are both conds true // are both conds true
// CHECK: %[[cond:.*]] = and %[[cmp0]], %[[cmp1]] : i1 // CHECK: %[[cond:.*]] = and %[[cmp0]], %[[cmp1]] : i1
Show All 18 Linesfunc @split_vector_transfer_read_strided_2d(
// CHECK: } // CHECK: }
// CHECK: %[[res:.*]] = vector.transfer_read {{.*}} {masked = [false, false]} : // CHECK: %[[res:.*]] = vector.transfer_read {{.*}} {masked = [false, false]} :
// CHECK-SAME: memref<?x8xf32, #[[$map_2d_stride_1]]>, vector<4x8xf32> // CHECK-SAME: memref<?x8xf32, #[[$map_2d_stride_1]]>, vector<4x8xf32>
// LINALG-DAG: %[[c0:.*]] = constant 0 : index // LINALG-DAG: %[[c0:.*]] = constant 0 : index
// LINALG-DAG: %[[c4:.*]] = constant 4 : index // LINALG-DAG: %[[c4:.*]] = constant 4 : index
// LINALG-DAG: %[[c7:.*]] = constant 7 : index // LINALG-DAG: %[[c7:.*]] = constant 7 : index
// LINALG-DAG: %[[c8:.*]] = constant 8 : index // LINALG-DAG: %[[c8:.*]] = constant 8 : index
// LINALG-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32
// alloca for boundary full tile // alloca for boundary full tile
// LINALG: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32> // LINALG: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32>
// LINALG-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32
// %i + 4 <= dim(%A, 0) // %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 // LINALG: %[[cmp0:.*]] = cmpi sle, %[[idx0]], %[[c7]] : index
// %j + 8 <= dim(%A, 1) // %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 // LINALG: %[[cmp1:.*]] = cmpi sle, %[[idx1]], %[[c8]] : index
// are both conds true // are both conds true
// LINALG: %[[cond:.*]] = and %[[cmp0]], %[[cmp1]] : i1 // LINALG: %[[cond:.*]] = and %[[cmp0]], %[[cmp1]] : i1
Show All 27 Lines

mlir/test/Dialect/Vector/vector-transfer-unroll.mlir

// RUN: mlir-opt %s -test-vector-transfer-unrolling-patterns | FileCheck %s // RUN: mlir-opt %s -test-vector-transfer-unrolling-patterns | FileCheck %s
// CHECK-LABEL: func @transfer_read_unroll // CHECK-LABEL: func @transfer_read_unroll
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[C2:.*]] = constant 2 : index // CHECK: %[[C2:.*]] = constant 2 : index
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[VTR0:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C0]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK: %[[VTR0:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C0]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTR1:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C2]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK-NEXT: %[[VTR1:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C2]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTR2:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C0]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK-NEXT: %[[VTR2:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C0]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTR3:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C2]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK-NEXT: %[[VTR3:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C2]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[TUPL:.*]] = vector.tuple %[[VTR0]], %[[VTR1]], %[[VTR2]], %[[VTR3]] : vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32> // CHECK-NEXT: %[[TUPL:.*]] = vector.tuple %[[VTR0]], %[[VTR1]], %[[VTR2]], %[[VTR3]] : vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VEC:.*]] = vector.insert_slices %[[TUPL]], [2, 2], [1, 1] : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> into vector<4x4xf32> // CHECK-NEXT: %[[VEC:.*]] = vector.insert_slices %[[TUPL]], [2, 2], [1, 1] : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> into vector<4x4xf32>
// CHECK-NEXT: return %[[VEC]] : vector<4x4xf32> // CHECK-NEXT: return %[[VEC]] : vector<4x4xf32>
func @transfer_read_unroll(%arg0 : memref<4x4xf32>) -> vector<4x4xf32> { func @transfer_read_unroll(%arg0 : memref<4x4xf32>) -> vector<4x4xf32> {
%c0 = constant 0 : index %c0 = constant 0 : index
%cf0 = constant 0.0 : f32 %cf0 = constant 0.0 : f32
%0 = vector.transfer_read %arg0[%c0, %c0], %cf0 : memref<4x4xf32>, vector<4x4xf32> %0 = vector.transfer_read %arg0[%c0, %c0], %cf0 : memref<4x4xf32>, vector<4x4xf32>
return %0 : vector<4x4xf32> return %0 : vector<4x4xf32>
} }
// CHECK-LABEL: func @transfer_write_unroll // CHECK-LABEL: func @transfer_write_unroll
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[C2:.*]] = constant 2 : index // CHECK: %[[C2:.*]] = constant 2 : index
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[TUPL:.*]] = vector.extract_slices {{.*}}, [2, 2], [1, 1] : vector<4x4xf32> into tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> // CHECK: %[[TUPL:.*]] = vector.extract_slices {{.*}}, [2, 2], [1, 1] : vector<4x4xf32> into tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
// CHECK-NEXT: %[[T0:.*]] = vector.tuple_get %[[TUPL]], 0 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> // CHECK-NEXT: %[[T0:.*]] = vector.tuple_get %[[TUPL]], 0 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
// CHECK-NEXT: vector.transfer_write %[[T0]], {{.*}}[%[[C0]], %[[C0]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32> // CHECK-NEXT: vector.transfer_write %[[T0]], {{.*}}[%[[C0]], %[[C0]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
// CHECK-NEXT: %[[T1:.*]] = vector.tuple_get %[[TUPL]], 1 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> // CHECK-NEXT: %[[T1:.*]] = vector.tuple_get %[[TUPL]], 1 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
// CHECK-NEXT: vector.transfer_write %[[T1]], {{.*}}[%[[C0]], %[[C2]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32> // CHECK-NEXT: vector.transfer_write %[[T1]], {{.*}}[%[[C0]], %[[C2]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
// CHECK-NEXT: %[[T2:.*]] = vector.tuple_get %[[TUPL]], 2 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> // CHECK-NEXT: %[[T2:.*]] = vector.tuple_get %[[TUPL]], 2 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
// CHECK-NEXT: vector.transfer_write %[[T2]], {{.*}}[%[[C2]], %[[C0]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32> // CHECK-NEXT: vector.transfer_write %[[T2]], {{.*}}[%[[C2]], %[[C0]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
// CHECK-NEXT: %[[T3:.*]] = vector.tuple_get %[[TUPL]], 3 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> // CHECK-NEXT: %[[T3:.*]] = vector.tuple_get %[[TUPL]], 3 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
// CHECK-NEXT: vector.transfer_write %[[T3]], {{.*}}[%[[C2]], %[[C2]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32> // CHECK-NEXT: vector.transfer_write %[[T3]], {{.*}}[%[[C2]], %[[C2]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
// CHECK-NEXT: return // CHECK-NEXT: return
func @transfer_write_unroll(%arg0 : memref<4x4xf32>, %arg1 : vector<4x4xf32>) { func @transfer_write_unroll(%arg0 : memref<4x4xf32>, %arg1 : vector<4x4xf32>) {
%c0 = constant 0 : index %c0 = constant 0 : index
vector.transfer_write %arg1, %arg0[%c0, %c0] : vector<4x4xf32>, memref<4x4xf32> vector.transfer_write %arg1, %arg0[%c0, %c0] : vector<4x4xf32>, memref<4x4xf32>
return return
} }
// CHECK-LABEL: func @transfer_readwrite_unroll // CHECK-LABEL: func @transfer_readwrite_unroll
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[C2:.*]] = constant 2 : index // CHECK: %[[C2:.*]] = constant 2 : index
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[VTR0:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C0]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK: %[[VTR0:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C0]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTR1:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C2]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK-NEXT: %[[VTR1:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C2]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTR2:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C0]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK-NEXT: %[[VTR2:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C0]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTR3:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C2]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK-NEXT: %[[VTR3:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C2]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: vector.transfer_write %[[VTR0]], {{.*}}[%[[C0]], %[[C0]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32> // CHECK-NEXT: vector.transfer_write %[[VTR0]], {{.*}}[%[[C0]], %[[C0]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
// CHECK-NEXT: vector.transfer_write %[[VTR1]], {{.*}}[%[[C0]], %[[C2]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32> // CHECK-NEXT: vector.transfer_write %[[VTR1]], {{.*}}[%[[C0]], %[[C2]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
// CHECK-NEXT: vector.transfer_write %[[VTR2]], {{.*}}[%[[C2]], %[[C0]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32> // CHECK-NEXT: vector.transfer_write %[[VTR2]], {{.*}}[%[[C2]], %[[C0]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
// CHECK-NEXT: vector.transfer_write %[[VTR3]], {{.*}}[%[[C2]], %[[C2]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32> // CHECK-NEXT: vector.transfer_write %[[VTR3]], {{.*}}[%[[C2]], %[[C2]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
// CHECK-NEXT: return // CHECK-NEXT: return
func @transfer_readwrite_unroll(%arg0 : memref<4x4xf32>) { func @transfer_readwrite_unroll(%arg0 : memref<4x4xf32>) {
%c0 = constant 0 : index %c0 = constant 0 : index
%cf0 = constant 0.0 : f32 %cf0 = constant 0.0 : f32
%0 = vector.transfer_read %arg0[%c0, %c0], %cf0 : memref<4x4xf32>, vector<4x4xf32> %0 = vector.transfer_read %arg0[%c0, %c0], %cf0 : memref<4x4xf32>, vector<4x4xf32>
vector.transfer_write %0, %arg0[%c0, %c0] : vector<4x4xf32>, memref<4x4xf32> vector.transfer_write %0, %arg0[%c0, %c0] : vector<4x4xf32>, memref<4x4xf32>
return return
} }
// CHECK-LABEL: func @transfer_read_unroll_tensor // CHECK-LABEL: func @transfer_read_unroll_tensor
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[C2:.*]] = constant 2 : index // CHECK: %[[C2:.*]] = constant 2 : index
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[VTR0:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C0]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32> // CHECK: %[[VTR0:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C0]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTR1:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C2]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32> // CHECK-NEXT: %[[VTR1:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C2]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTR2:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C0]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32> // CHECK-NEXT: %[[VTR2:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C0]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTR3:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C2]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32> // CHECK-NEXT: %[[VTR3:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C2]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[TUPL:.*]] = vector.tuple %[[VTR0]], %[[VTR1]], %[[VTR2]], %[[VTR3]] : vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32> // CHECK-NEXT: %[[TUPL:.*]] = vector.tuple %[[VTR0]], %[[VTR1]], %[[VTR2]], %[[VTR3]] : vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VEC:.*]] = vector.insert_slices %[[TUPL]], [2, 2], [1, 1] : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> into vector<4x4xf32> // CHECK-NEXT: %[[VEC:.*]] = vector.insert_slices %[[TUPL]], [2, 2], [1, 1] : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> into vector<4x4xf32>
// CHECK-NEXT: return %[[VEC]] : vector<4x4xf32> // CHECK-NEXT: return %[[VEC]] : vector<4x4xf32>
func @transfer_read_unroll_tensor(%arg0 : tensor<4x4xf32>) -> vector<4x4xf32> { func @transfer_read_unroll_tensor(%arg0 : tensor<4x4xf32>) -> vector<4x4xf32> {
%c0 = constant 0 : index %c0 = constant 0 : index
%cf0 = constant 0.0 : f32 %cf0 = constant 0.0 : f32
%0 = vector.transfer_read %arg0[%c0, %c0], %cf0 : tensor<4x4xf32>, vector<4x4xf32> %0 = vector.transfer_read %arg0[%c0, %c0], %cf0 : tensor<4x4xf32>, vector<4x4xf32>
return %0 : vector<4x4xf32> return %0 : vector<4x4xf32>
} }
// CHECK-LABEL: func @transfer_write_unroll_tensor // CHECK-LABEL: func @transfer_write_unroll_tensor
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[C2:.*]] = constant 2 : index // CHECK: %[[C2:.*]] = constant 2 : index
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[TUPL:.*]] = vector.extract_slices {{.*}}, [2, 2], [1, 1] : vector<4x4xf32> into tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> // CHECK: %[[TUPL:.*]] = vector.extract_slices {{.*}}, [2, 2], [1, 1] : vector<4x4xf32> into tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
// CHECK-NEXT: %[[T0:.*]] = vector.tuple_get %[[TUPL]], 0 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> // CHECK-NEXT: %[[T0:.*]] = vector.tuple_get %[[TUPL]], 0 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
// CHECK-NEXT: %[[VTW0:.*]] = vector.transfer_write %[[T0]], {{.*}}[%[[C0]], %[[C0]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32> // CHECK-NEXT: %[[VTW0:.*]] = vector.transfer_write %[[T0]], {{.*}}[%[[C0]], %[[C0]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>
// CHECK-NEXT: %[[T1:.*]] = vector.tuple_get %[[TUPL]], 1 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> // CHECK-NEXT: %[[T1:.*]] = vector.tuple_get %[[TUPL]], 1 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
// CHECK-NEXT: %[[VTW1:.*]] = vector.transfer_write %[[T1]], %[[VTW0]][%[[C0]], %[[C2]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32> // CHECK-NEXT: %[[VTW1:.*]] = vector.transfer_write %[[T1]], %[[VTW0]][%[[C0]], %[[C2]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>
// CHECK-NEXT: %[[T2:.*]] = vector.tuple_get %[[TUPL]], 2 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> // CHECK-NEXT: %[[T2:.*]] = vector.tuple_get %[[TUPL]], 2 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
// CHECK-NEXT: %[[VTW2:.*]] = vector.transfer_write %[[T2]], %[[VTW1]][%[[C2]], %[[C0]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32> // CHECK-NEXT: %[[VTW2:.*]] = vector.transfer_write %[[T2]], %[[VTW1]][%[[C2]], %[[C0]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>
// CHECK-NEXT: %[[T3:.*]] = vector.tuple_get %[[TUPL]], 3 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> // CHECK-NEXT: %[[T3:.*]] = vector.tuple_get %[[TUPL]], 3 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
// CHECK-NEXT: %[[VTW3:.*]] = vector.transfer_write %[[T3]], %[[VTW2]][%[[C2]], %[[C2]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32> // CHECK-NEXT: %[[VTW3:.*]] = vector.transfer_write %[[T3]], %[[VTW2]][%[[C2]], %[[C2]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>
// CHECK-NEXT: return %[[VTW3]] : tensor<4x4xf32> // CHECK-NEXT: return %[[VTW3]] : tensor<4x4xf32>
func @transfer_write_unroll_tensor(%arg0 : tensor<4x4xf32>, func @transfer_write_unroll_tensor(%arg0 : tensor<4x4xf32>,
%arg1 : vector<4x4xf32>) -> tensor<4x4xf32> { %arg1 : vector<4x4xf32>) -> tensor<4x4xf32> {
%c0 = constant 0 : index %c0 = constant 0 : index
%r = vector.transfer_write %arg1, %arg0[%c0, %c0] : %r = vector.transfer_write %arg1, %arg0[%c0, %c0] :
vector<4x4xf32>, tensor<4x4xf32> vector<4x4xf32>, tensor<4x4xf32>
return %r: tensor<4x4xf32> return %r: tensor<4x4xf32>
} }
// CHECK-LABEL: func @transfer_readwrite_unroll_tensor // CHECK-LABEL: func @transfer_readwrite_unroll_tensor
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[C2:.*]] = constant 2 : index // CHECK: %[[C2:.*]] = constant 2 : index
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[VTR0:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C0]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32> // CHECK: %[[VTR0:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C0]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTR1:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C2]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32> // CHECK-NEXT: %[[VTR1:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C2]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTR2:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C0]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32> // CHECK-NEXT: %[[VTR2:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C0]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTR3:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C2]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32> // CHECK-NEXT: %[[VTR3:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C2]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTW0:.*]] = vector.transfer_write %[[VTR0]], {{.*}}[%[[C0]], %[[C0]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32> // CHECK-NEXT: %[[VTW0:.*]] = vector.transfer_write %[[VTR0]], {{.*}}[%[[C0]], %[[C0]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>
// CHECK-NEXT: %[[VTW1:.*]] = vector.transfer_write %[[VTR1]], %[[VTW0]][%[[C0]], %[[C2]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32> // CHECK-NEXT: %[[VTW1:.*]] = vector.transfer_write %[[VTR1]], %[[VTW0]][%[[C0]], %[[C2]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>
// CHECK-NEXT: %[[VTW2:.*]] = vector.transfer_write %[[VTR2]], %[[VTW1]][%[[C2]], %[[C0]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32> // CHECK-NEXT: %[[VTW2:.*]] = vector.transfer_write %[[VTR2]], %[[VTW1]][%[[C2]], %[[C0]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>
// CHECK-NEXT: %[[VTW3:.*]] = vector.transfer_write %[[VTR3]], %[[VTW2]][%[[C2]], %[[C2]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32> // CHECK-NEXT: %[[VTW3:.*]] = vector.transfer_write %[[VTR3]], %[[VTW2]][%[[C2]], %[[C2]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>
Show All 10 Lines

mlir/test/Dialect/Vector/vector-transforms.mlir

Show First 20 Lines • Show All 219 Lines • ▼ Show 20 Linesfunc @contraction4x4_ikj(%arg0 : vector<4x2xf32>, %arg1 : vector<2x4xf32>,
%0 = vector.contract #contraction_trait1 %arg0, %arg1, %arg2, %lhsm, %rhsm %0 = vector.contract #contraction_trait1 %arg0, %arg1, %arg2, %lhsm, %rhsm
: vector<4x2xf32>, vector<2x4xf32> into vector<4x4xf32> : vector<4x2xf32>, vector<2x4xf32> into vector<4x4xf32>
return %0 : vector<4x4xf32> return %0 : vector<4x4xf32>
} }
// CHECK-LABEL: func @contraction4x4_ikj_xfer_read // CHECK-LABEL: func @contraction4x4_ikj_xfer_read
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[C2:.*]] = constant 2 : index // CHECK: %[[C2:.*]] = constant 2 : index
// CHECK: %[[C0:.*]] = constant 0 : index
// Check LHS vector.transfer read is split for each user. // Check LHS vector.transfer read is split for each user.
// CHECK: %[[VTR0:.*]] = vector.transfer_read %{{.*}}[%[[C0]], %[[C0]]], %{{.*}} : memref<4x2xf32>, vector<2x2xf32> // CHECK: %[[VTR0:.*]] = vector.transfer_read %{{.*}}[%[[C0]], %[[C0]]], %{{.*}} : memref<4x2xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTR1:.*]] = vector.transfer_read %{{.*}}[%[[C2]], %[[C0]]], %{{.*}} : memref<4x2xf32>, vector<2x2xf32> // CHECK-NEXT: %[[VTR1:.*]] = vector.transfer_read %{{.*}}[%[[C2]], %[[C0]]], %{{.*}} : memref<4x2xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTR2:.*]] = vector.transfer_read %{{.*}}[%[[C0]], %[[C0]]], %{{.*}} : memref<2x4xf32>, vector<2x2xf32> // CHECK-NEXT: %[[VTR2:.*]] = vector.transfer_read %{{.*}}[%[[C0]], %[[C0]]], %{{.*}} : memref<2x4xf32>, vector<2x2xf32>
// CHECK-NEXT: %[[VTR3:.*]] = vector.transfer_read %{{.*}}[%[[C0]], %[[C2]]], %{{.*}} : memref<2x4xf32>, vector<2x2xf32> // CHECK-NEXT: %[[VTR3:.*]] = vector.transfer_read %{{.*}}[%[[C0]], %[[C2]]], %{{.*}} : memref<2x4xf32>, vector<2x2xf32>
▲ Show 20 Lines • Show All 179 Lines • ▼ Show 20 Lines
// CHECK: return %[[A0]] : vector<2x4xf32> // CHECK: return %[[A0]] : vector<2x4xf32>
func @cancelling_shape_cast_ops(%arg0 : vector<2x4xf32>) -> vector<2x4xf32> { func @cancelling_shape_cast_ops(%arg0 : vector<2x4xf32>) -> vector<2x4xf32> {
%0 = vector.shape_cast %arg0 : vector<2x4xf32> to vector<8xf32> %0 = vector.shape_cast %arg0 : vector<2x4xf32> to vector<8xf32>
%1 = vector.shape_cast %0 : vector<8xf32> to vector<2x4xf32> %1 = vector.shape_cast %0 : vector<8xf32> to vector<2x4xf32>
return %1 : vector<2x4xf32> return %1 : vector<2x4xf32>
} }
// CHECK-LABEL: func @vector_transfers_vector_element_type // CHECK-LABEL: func @vector_transfers_vector_element_type
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[C1:.*]] = constant 1 : index // CHECK: %[[C1:.*]] = constant 1 : index
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[VTR0:.*]] = vector.transfer_read %{{.*}}[%[[C0]], %[[C0]], %[[C0]]], %{{.*}} {masked = [false, false]} : memref<6x2x1xvector<2x4xf32>>, vector<1x1x2x4xf32> // CHECK: %[[VTR0:.*]] = vector.transfer_read %{{.*}}[%[[C0]], %[[C0]], %[[C0]]], %{{.*}} {masked = [false, false]} : memref<6x2x1xvector<2x4xf32>>, vector<1x1x2x4xf32>
// CHECK-NEXT: %[[VTR1:.*]] = vector.transfer_read %{{.*}}[%[[C0]], %[[C1]], %[[C0]]], %{{.*}} {masked = [false, false]} : memref<6x2x1xvector<2x4xf32>>, vector<1x1x2x4xf32> // CHECK-NEXT: %[[VTR1:.*]] = vector.transfer_read %{{.*}}[%[[C0]], %[[C1]], %[[C0]]], %{{.*}} {masked = [false, false]} : memref<6x2x1xvector<2x4xf32>>, vector<1x1x2x4xf32>
// CHECK-NEXT: vector.transfer_write %[[VTR0]], %{{.*}}[%[[C0]], %[[C0]], %[[C0]]] {masked = [false, false]} : vector<1x1x2x4xf32>, memref<6x2x1xvector<2x4xf32>> // CHECK-NEXT: vector.transfer_write %[[VTR0]], %{{.*}}[%[[C0]], %[[C0]], %[[C0]]] {masked = [false, false]} : vector<1x1x2x4xf32>, memref<6x2x1xvector<2x4xf32>>
// CHECK-NEXT: vector.transfer_write %[[VTR1]], %{{.*}}[%[[C0]], %[[C1]], %[[C0]]] {masked = [false, false]} : vector<1x1x2x4xf32>, memref<6x2x1xvector<2x4xf32>> // CHECK-NEXT: vector.transfer_write %[[VTR1]], %{{.*}}[%[[C0]], %[[C1]], %[[C0]]] {masked = [false, false]} : vector<1x1x2x4xf32>, memref<6x2x1xvector<2x4xf32>>
func @vector_transfers_vector_element_type() { func @vector_transfers_vector_element_type() {
%c0 = constant 0 : index %c0 = constant 0 : index
%cf0 = constant 0.000000e+00 : f32 %cf0 = constant 0.000000e+00 : f32
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Linesfunc @shape_cast_fold(%arg0 : vector<5x4x2xf32>, %arg1 : vector<3x4x2xf32>)
%6 = vector.tuple_get %5, 0 : tuple<vector<5x4x2xf32>, vector<3x4x2xf32>> %6 = vector.tuple_get %5, 0 : tuple<vector<5x4x2xf32>, vector<3x4x2xf32>>
%7 = vector.tuple_get %5, 1 : tuple<vector<5x4x2xf32>, vector<3x4x2xf32>> %7 = vector.tuple_get %5, 1 : tuple<vector<5x4x2xf32>, vector<3x4x2xf32>>
return %6, %7 : vector<5x4x2xf32>, vector<3x4x2xf32> return %6, %7 : vector<5x4x2xf32>, vector<3x4x2xf32>
} }
// CHECK-LABEL: func @elementwise_unroll // CHECK-LABEL: func @elementwise_unroll
// CHECK-SAME: (%[[ARG0:.*]]: memref<4x4xf32>, %[[ARG1:.*]]: memref<4x4xf32>) // CHECK-SAME: (%[[ARG0:.*]]: memref<4x4xf32>, %[[ARG1:.*]]: memref<4x4xf32>)
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[C2:.*]] = constant 2 : index // CHECK: %[[C2:.*]] = constant 2 : index
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[VT0:.*]] = vector.transfer_read %[[ARG0]][%[[C0]], %[[C0]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK: %[[VT0:.*]] = vector.transfer_read %[[ARG0]][%[[C0]], %[[C0]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>
// CHECK: %[[VT1:.*]] = vector.transfer_read %[[ARG0]][%[[C0]], %[[C2]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK: %[[VT1:.*]] = vector.transfer_read %[[ARG0]][%[[C0]], %[[C2]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>
// CHECK: %[[VT2:.*]] = vector.transfer_read %[[ARG0]][%[[C2]], %[[C0]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK: %[[VT2:.*]] = vector.transfer_read %[[ARG0]][%[[C2]], %[[C0]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>
// CHECK: %[[VT3:.*]] = vector.transfer_read %[[ARG0]][%[[C2]], %[[C2]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK: %[[VT3:.*]] = vector.transfer_read %[[ARG0]][%[[C2]], %[[C2]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>
// CHECK: %[[VT4:.*]] = vector.transfer_read %[[ARG1]][%[[C0]], %[[C0]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK: %[[VT4:.*]] = vector.transfer_read %[[ARG1]][%[[C0]], %[[C0]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>
// CHECK: %[[VT5:.*]] = vector.transfer_read %[[ARG1]][%[[C0]], %[[C2]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK: %[[VT5:.*]] = vector.transfer_read %[[ARG1]][%[[C0]], %[[C2]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>
// CHECK: %[[VT6:.*]] = vector.transfer_read %[[ARG1]][%[[C2]], %[[C0]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK: %[[VT6:.*]] = vector.transfer_read %[[ARG1]][%[[C2]], %[[C0]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>
// CHECK: %[[VT7:.*]] = vector.transfer_read %[[ARG1]][%[[C2]], %[[C2]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32> // CHECK: %[[VT7:.*]] = vector.transfer_read %[[ARG1]][%[[C2]], %[[C2]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>
▲ Show 20 Lines • Show All 234 Lines • Show Last 20 Lines

mlir/test/Transforms/canonicalize.mlir

Show First 20 Lines • Show All 566 Lines • ▼ Show 20 Lines
// //
// IMPORTANT NOTE: the operations in this test are exactly those produced by // IMPORTANT NOTE: the operations in this test are exactly those produced by
// lowering affine.apply affine_map<(i) -> (i mod 42)> to standard operations. Please only // lowering affine.apply affine_map<(i) -> (i mod 42)> to standard operations. Please only
// change these operations together with the affine lowering pass tests. // change these operations together with the affine lowering pass tests.
// //
// CHECK-LABEL: @lowered_affine_mod // CHECK-LABEL: @lowered_affine_mod
func @lowered_affine_mod() -> (index, index) { func @lowered_affine_mod() -> (index, index) {
// CHECK-NEXT: {{.*}} = constant 1 : index
// CHECK-NEXT: {{.*}} = constant 41 : index // CHECK-NEXT: {{.*}} = constant 41 : index
%c-43 = constant -43 : index %c-43 = constant -43 : index
%c42 = constant 42 : index %c42 = constant 42 : index
%0 = remi_signed %c-43, %c42 : index %0 = remi_signed %c-43, %c42 : index
%c0 = constant 0 : index %c0 = constant 0 : index
%1 = cmpi slt, %0, %c0 : index %1 = cmpi slt, %0, %c0 : index
%2 = addi %0, %c42 : index %2 = addi %0, %c42 : index
%3 = select %1, %2, %0 : index %3 = select %1, %2, %0 : index
// CHECK-NEXT: {{.*}} = constant 1 : index
%c43 = constant 43 : index %c43 = constant 43 : index
%c42_0 = constant 42 : index %c42_0 = constant 42 : index
%4 = remi_signed %c43, %c42_0 : index %4 = remi_signed %c43, %c42_0 : index
%c0_1 = constant 0 : index %c0_1 = constant 0 : index
%5 = cmpi slt, %4, %c0_1 : index %5 = cmpi slt, %4, %c0_1 : index
%6 = addi %4, %c42_0 : index %6 = addi %4, %c42_0 : index
%7 = select %5, %6, %4 : index %7 = select %5, %6, %4 : index
return %3, %7 : index, index return %3, %7 : index, index
} }
// //
// IMPORTANT NOTE: the operations in this test are exactly those produced by // IMPORTANT NOTE: the operations in this test are exactly those produced by
// lowering affine.apply affine_map<(i) -> (i mod 42)> to standard operations. Please only // lowering affine.apply affine_map<(i) -> (i mod 42)> to standard operations. Please only
// change these operations together with the affine lowering pass tests. // change these operations together with the affine lowering pass tests.
// //
// CHECK-LABEL: func @lowered_affine_floordiv // CHECK-LABEL: func @lowered_affine_floordiv
func @lowered_affine_floordiv() -> (index, index) { func @lowered_affine_floordiv() -> (index, index) {
// CHECK-NEXT: %c1 = constant 1 : index
// CHECK-NEXT: %c-2 = constant -2 : index // CHECK-NEXT: %c-2 = constant -2 : index
%c-43 = constant -43 : index %c-43 = constant -43 : index
%c42 = constant 42 : index %c42 = constant 42 : index
%c0 = constant 0 : index %c0 = constant 0 : index
%c-1 = constant -1 : index %c-1 = constant -1 : index
%0 = cmpi slt, %c-43, %c0 : index %0 = cmpi slt, %c-43, %c0 : index
%1 = subi %c-1, %c-43 : index %1 = subi %c-1, %c-43 : index
%2 = select %0, %1, %c-43 : index %2 = select %0, %1, %c-43 : index
%3 = divi_signed %2, %c42 : index %3 = divi_signed %2, %c42 : index
%4 = subi %c-1, %3 : index %4 = subi %c-1, %3 : index
%5 = select %0, %4, %3 : index %5 = select %0, %4, %3 : index
// CHECK-NEXT: %c1 = constant 1 : index
%c43 = constant 43 : index %c43 = constant 43 : index
%c42_0 = constant 42 : index %c42_0 = constant 42 : index
%c0_1 = constant 0 : index %c0_1 = constant 0 : index
%c-1_2 = constant -1 : index %c-1_2 = constant -1 : index
%6 = cmpi slt, %c43, %c0_1 : index %6 = cmpi slt, %c43, %c0_1 : index
%7 = subi %c-1_2, %c43 : index %7 = subi %c-1_2, %c43 : index
%8 = select %6, %7, %c43 : index %8 = select %6, %7, %c43 : index
%9 = divi_signed %8, %c42_0 : index %9 = divi_signed %8, %c42_0 : index
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines
// 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_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_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)> // CHECK-DAG: #[[$SUBVIEW_MAP8:map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 4 + d1 + 12)>
// CHECK-LABEL: func @subview // CHECK-LABEL: func @subview
// CHECK-SAME: %[[ARG0:.*]]: index, %[[ARG1:.*]]: index // CHECK-SAME: %[[ARG0:.*]]: index, %[[ARG1:.*]]: index
func @subview(%arg0 : index, %arg1 : index) -> (index, index) { func @subview(%arg0 : index, %arg1 : index) -> (index, index) {
// CHECK: %[[C0:.*]] = constant 0 : index // Folded but reappears after subview folding into dim.
// CHECK: %[[C11:.*]] = constant 11 : index
%c0 = constant 0 : index %c0 = constant 0 : index
// CHECK-NOT: constant 1 : index // CHECK-NOT: constant 1 : index
%c1 = constant 1 : index %c1 = constant 1 : index
// CHECK-NOT: constant 2 : index // CHECK-NOT: constant 2 : index
%c2 = constant 2 : index %c2 = constant 2 : index
// Folded but reappears after subview folding into dim. // Folded but reappears after subview folding into dim.
// CHECK: %[[C7:.*]] = constant 7 : index // CHECK: %[[C7:.*]] = constant 7 : index
%c7 = constant 7 : index %c7 = constant 7 : index
// Folded but reappears after subview folding into dim.
// CHECK: %[[C11:.*]] = constant 11 : index
%c11 = constant 11 : index %c11 = constant 11 : index
// CHECK-NOT: constant 15 : index // CHECK-NOT: constant 15 : index
%c15 = constant 15 : index %c15 = constant 15 : index
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[ALLOC0:.*]] = alloc() // CHECK: %[[ALLOC0:.*]] = alloc()
%0 = alloc() : memref<8x16x4xf32, offset : 0, strides : [64, 4, 1]> %0 = alloc() : memref<8x16x4xf32, offset : 0, strides : [64, 4, 1]>
// Test: subview with constant base memref and constant operands is folded. // Test: subview with constant base memref and constant operands is folded.
// Note that the subview uses the base memrefs layout map because it used // Note that the subview uses the base memrefs layout map because it used
// zero offset and unit stride arguments. // zero offset and unit stride arguments.
// CHECK: subview %[[ALLOC0]][0, 0, 0] [7, 11, 2] [1, 1, 1] : // CHECK: subview %[[ALLOC0]][0, 0, 0] [7, 11, 2] [1, 1, 1] :
▲ Show 20 Lines • Show All 141 Lines • ▼ Show 20 Lines
} }
// CHECK-LABEL: func @index_cast_fold // CHECK-LABEL: func @index_cast_fold
func @index_cast_fold() -> (i16, index) { func @index_cast_fold() -> (i16, index) {
%c4 = constant 4 : index %c4 = constant 4 : index
%1 = index_cast %c4 : index to i16 %1 = index_cast %c4 : index to i16
%c4_i16 = constant 4 : i16 %c4_i16 = constant 4 : i16
%2 = index_cast %c4_i16 : i16 to index %2 = index_cast %c4_i16 : i16 to index
// CHECK: %[[C4_I16:.*]] = constant 4 : i16
// CHECK: %[[C4:.*]] = constant 4 : index // CHECK: %[[C4:.*]] = constant 4 : index
// CHECK: %[[C4_I16:.*]] = constant 4 : i16
// CHECK: return %[[C4_I16]], %[[C4]] : i16, index // CHECK: return %[[C4_I16]], %[[C4]] : i16, index
return %1, %2 : i16, index return %1, %2 : i16, index
} }
// CHECK-LABEL: func @remove_dead_else // CHECK-LABEL: func @remove_dead_else
func @remove_dead_else(%M : memref<100 x i32>) { func @remove_dead_else(%M : memref<100 x i32>) {
affine.for %i = 0 to 100 { affine.for %i = 0 to 100 {
affine.load %M[%i] : memref<100xi32> affine.load %M[%i] : memref<100xi32>
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

mlir/test/Transforms/parallel-loop-collapsing.mlir

Show All 22 Linesfunc @parallel_many_dims() {
scf.parallel (%i0, %i1, %i2, %i3, %i4) = (%c0, %c3, %c6, %c9, %c12) scf.parallel (%i0, %i1, %i2, %i3, %i4) = (%c0, %c3, %c6, %c9, %c12)
to (%c2, %c5, %c8, %c26, %c14) step (%c1, %c4, %c7, %c10, %c13) { to (%c2, %c5, %c8, %c26, %c14) step (%c1, %c4, %c7, %c10, %c13) {
%result = "magic.op"(%i0, %i1, %i2, %i3, %i4) %result = "magic.op"(%i0, %i1, %i2, %i3, %i4)
: (index, index, index, index, index) -> index : (index, index, index, index, index) -> index
} }
return return
} }
// CHECK: [[C3:%.*]] = constant 3 : index // CHECK: [[C12:%.*]] = constant 12 : index
// CHECK: [[C6:%.*]] = constant 6 : index
// CHECK: [[C9:%.*]] = constant 9 : index
// CHECK: [[C10:%.*]] = constant 10 : index // CHECK: [[C10:%.*]] = constant 10 : index
// CHECK: [[C9:%.*]] = constant 9 : index
// CHECK: [[C6:%.*]] = constant 6 : index
// CHECK: [[C4:%.*]] = constant 4 : index // CHECK: [[C4:%.*]] = constant 4 : index
// CHECK: [[C12:%.*]] = constant 12 : index // CHECK: [[C3:%.*]] = constant 3 : index
// CHECK: [[C0:%.*]] = constant 0 : index
// CHECK: [[C1:%.*]] = constant 1 : index
// CHECK: [[C2:%.*]] = constant 2 : index // CHECK: [[C2:%.*]] = constant 2 : index
// CHECK: [[C1:%.*]] = constant 1 : index
// CHECK: [[C0:%.*]] = constant 0 : index
// CHECK: scf.parallel ([[NEW_I0:%.*]]) = ([[C0]]) to ([[C4]]) step ([[C1]]) { // CHECK: scf.parallel ([[NEW_I0:%.*]]) = ([[C0]]) to ([[C4]]) step ([[C1]]) {
// CHECK: [[V0:%.*]] = remi_signed [[NEW_I0]], [[C2]] : index // CHECK: [[V0:%.*]] = remi_signed [[NEW_I0]], [[C2]] : index
// CHECK: [[I0:%.*]] = divi_signed [[NEW_I0]], [[C2]] : index // CHECK: [[I0:%.*]] = divi_signed [[NEW_I0]], [[C2]] : index
// CHECK: [[V2:%.*]] = muli [[V0]], [[C10]] : index // CHECK: [[V2:%.*]] = muli [[V0]], [[C10]] : index
// CHECK: [[I3:%.*]] = addi [[V2]], [[C9]] : index // CHECK: [[I3:%.*]] = addi [[V2]], [[C9]] : index
// CHECK: "magic.op"([[I0]], [[C3]], [[C6]], [[I3]], [[C12]]) : (index, index, index, index, index) -> index // CHECK: "magic.op"([[I0]], [[C3]], [[C6]], [[I3]], [[C12]]) : (index, index, index, index, index) -> index
// CHECK: scf.yield // CHECK: scf.yield

mlir/test/Transforms/single-parallel-loop-collapsing.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(parallel-loop-collapsing{collapsed-indices-0=0,1}, canonicalize)' | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(parallel-loop-collapsing{collapsed-indices-0=0,1}, canonicalize)' | FileCheck %s
func @collapse_to_single() { func @collapse_to_single() {
%c0 = constant 3 : index %c0 = constant 3 : index
%c1 = constant 7 : index %c1 = constant 7 : index
%c2 = constant 11 : index %c2 = constant 11 : index
%c3 = constant 29 : index %c3 = constant 29 : index
%c4 = constant 3 : index %c4 = constant 3 : index
%c5 = constant 4 : index %c5 = constant 4 : index
scf.parallel (%i0, %i1) = (%c0, %c1) to (%c2, %c3) step (%c4, %c5) { scf.parallel (%i0, %i1) = (%c0, %c1) to (%c2, %c3) step (%c4, %c5) {
%result = "magic.op"(%i0, %i1): (index, index) -> index %result = "magic.op"(%i0, %i1): (index, index) -> index
} }
return return
} }
// CHECK-LABEL: func @collapse_to_single() { // CHECK-LABEL: func @collapse_to_single() {
// CHECK: [[C7:%.*]] = constant 7 : index // CHECK-DAG: [[C18:%.*]] = constant 18 : index
rriddleUnsubmitted
Done
ReplyInline Actions

Can you just update these(and the other newly broken cases) to CHECK-DAG?

rriddle: Can you just update these(and the other newly broken cases) to CHECK-DAG?
// CHECK: [[C3:%.*]] = constant 3 : index // CHECK-DAG: [[C6:%.*]] = constant 6 : index
// CHECK: [[C4:%.*]] = constant 4 : index // CHECK-DAG: [[C3:%.*]] = constant 3 : index
// CHECK: [[C18:%.*]] = constant 18 : index // CHECK-DAG: [[C7:%.*]] = constant 7 : index
// CHECK: [[C6:%.*]] = constant 6 : index // CHECK-DAG: [[C4:%.*]] = constant 4 : index
// CHECK: [[C0:%.*]] = constant 0 : index // CHECK-DAG: [[C1:%.*]] = constant 1 : index
// CHECK: [[C1:%.*]] = constant 1 : index // CHECK-DAG: [[C0:%.*]] = constant 0 : index
// CHECK: scf.parallel ([[NEW_I:%.*]]) = ([[C0]]) to ([[C18]]) step ([[C1]]) { // CHECK: scf.parallel ([[NEW_I:%.*]]) = ([[C0]]) to ([[C18]]) step ([[C1]]) {
// CHECK: [[I0_COUNT:%.*]] = remi_signed [[NEW_I]], [[C6]] : index // CHECK: [[I0_COUNT:%.*]] = remi_signed [[NEW_I]], [[C6]] : index
// CHECK: [[I1_COUNT:%.*]] = divi_signed [[NEW_I]], [[C6]] : index // CHECK: [[I1_COUNT:%.*]] = divi_signed [[NEW_I]], [[C6]] : index
// CHECK: [[V0:%.*]] = muli [[I0_COUNT]], [[C4]] : index // CHECK: [[V0:%.*]] = muli [[I0_COUNT]], [[C4]] : index
// CHECK: [[I1:%.*]] = addi [[V0]], [[C7]] : index // CHECK: [[I1:%.*]] = addi [[V0]], [[C7]] : index
// CHECK: [[V1:%.*]] = muli [[I1_COUNT]], [[C3]] : index // CHECK: [[V1:%.*]] = muli [[I1_COUNT]], [[C3]] : index
// CHECK: [[I0:%.*]] = addi [[V1]], [[C3]] : index // CHECK: [[I0:%.*]] = addi [[V1]], [[C3]] : index
// CHECK: "magic.op"([[I0]], [[I1]]) : (index, index) -> index // CHECK: "magic.op"([[I0]], [[I1]]) : (index, index) -> index
// CHECK: scf.yield // CHECK: scf.yield
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return

mlir/test/Transforms/test-canonicalize.mlir

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Linesfunc @test_commutative_multi(%arg0: i32, %arg1: i32) -> (i32, i32) {
%y = "test.op_commutative"(%c42_i32, %arg0, %arg1, %c43_i32) : (i32, i32, i32, i32) -> i32 %y = "test.op_commutative"(%c42_i32, %arg0, %arg1, %c43_i32) : (i32, i32, i32, i32) -> i32
// CHECK-NEXT: %[[O1:.*]] = "test.op_commutative"(%[[ARG_0]], %[[ARG_1]], %[[C42]], %[[C43]]) : (i32, i32, i32, i32) -> i32 // CHECK-NEXT: %[[O1:.*]] = "test.op_commutative"(%[[ARG_0]], %[[ARG_1]], %[[C42]], %[[C43]]) : (i32, i32, i32, i32) -> i32
%z = "test.op_commutative"(%arg0, %c42_i32, %c43_i32, %arg1): (i32, i32, i32, i32) -> i32 %z = "test.op_commutative"(%arg0, %c42_i32, %c43_i32, %arg1): (i32, i32, i32, i32) -> i32
// CHECK-NEXT: return %[[O0]], %[[O1]] // CHECK-NEXT: return %[[O0]], %[[O1]]
return %y, %z: i32, i32 return %y, %z: i32, i32
} }
// CHECK-LABEL: func @test_commutative_multi_cst
func @test_commutative_multi_cst(%arg0: i32, %arg1: i32) -> (i32, i32) {
// CHECK-NEXT: %c42_i32 = constant 42 : i32
%c42_i32 = constant 42 : i32
%c42_i32_2 = constant 42 : i32
// CHECK-NEXT: %[[O0:.*]] = "test.op_commutative"(%arg0, %arg1, %c42_i32, %c42_i32) : (i32, i32, i32, i32) -> i32
%y = "test.op_commutative"(%c42_i32, %arg0, %arg1, %c42_i32_2) : (i32, i32, i32, i32) -> i32
%c42_i32_3 = constant 42 : i32
// CHECK-NEXT: %[[O1:.*]] = "test.op_commutative"(%arg0, %arg1, %c42_i32, %c42_i32) : (i32, i32, i32, i32) -> i32
%z = "test.op_commutative"(%arg0, %c42_i32_3, %c42_i32_2, %arg1): (i32, i32, i32, i32) -> i32
// CHECK-NEXT: return %[[O0]], %[[O1]]
return %y, %z: i32, i32
}
// CHECK-LABEL: func @typemismatch
func @typemismatch() -> i32 { func @typemismatch() -> i32 {
%c42 = constant 42.0 : f32 %c42 = constant 42.0 : f32
// The "passthrough_fold" folder will naively return its operand, but we don't // The "passthrough_fold" folder will naively return its operand, but we don't
// want to fold here because of the type mismatch. // want to fold here because of the type mismatch.
// CHECK: "test.passthrough_fold" // CHECK: "test.passthrough_fold"
%0 = "test.passthrough_fold"(%c42) : (f32) -> (i32) %0 = "test.passthrough_fold"(%c42) : (f32) -> (i32)
return %0 : i32 return %0 : i32
} }

mlir/test/mlir-tblgen/pattern.mlir

// RUN: mlir-opt -test-patterns -mlir-print-debuginfo -mlir-print-local-scope %s | FileCheck %s // RUN: mlir-opt -test-patterns -mlir-print-debuginfo -mlir-print-local-scope %s | FileCheck %s
// CHECK-LABEL: verifyFusedLocs // CHECK-LABEL: verifyFusedLocs
func @verifyFusedLocs(%arg0 : i32) -> i32 { func @verifyFusedLocs(%arg0 : i32) -> i32 {
%0 = "test.op_a"(%arg0) {attr = 10 : i32} : (i32) -> i32 loc("a") %0 = "test.op_a"(%arg0) {attr = 10 : i32} : (i32) -> i32 loc("a")
%result = "test.op_a"(%0) {attr = 20 : i32} : (i32) -> i32 loc("b") %result = "test.op_a"(%0) {attr = 20 : i32} : (i32) -> i32 loc("b")
// CHECK: "test.op_b"(%arg0) {attr = 10 : i32} : (i32) -> i32 loc("a") // CHECK: %0 = "test.op_b"(%arg0) {attr = 10 : i32} : (i32) -> i32 loc("a")
// CHECK: "test.op_b"(%arg0) {attr = 20 : i32} : (i32) -> i32 loc(fused["b", "a"]) // CHECK: %1 = "test.op_b"(%0) {attr = 20 : i32} : (i32) -> i32 loc("b")
return %result : i32 return %result : i32
} }
// CHECK-LABEL: verifyDesignatedLoc // CHECK-LABEL: verifyDesignatedLoc
func @verifyDesignatedLoc(%arg0 : i32) -> i32 { func @verifyDesignatedLoc(%arg0 : i32) -> i32 {
%0 = "test.loc_src"(%arg0) : (i32) -> i32 loc("loc3") %0 = "test.loc_src"(%arg0) : (i32) -> i32 loc("loc3")
%1 = "test.loc_src"(%0) : (i32) -> i32 loc("loc2") %1 = "test.loc_src"(%0) : (i32) -> i32 loc("loc2")
%2 = "test.loc_src"(%1) : (i32) -> i32 loc("loc1") %2 = "test.loc_src"(%1) : (i32) -> i32 loc("loc1")
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
// CHECK-LABEL: verifyBenefit // CHECK-LABEL: verifyBenefit
func @verifyBenefit(%arg0 : i32) -> i32 { func @verifyBenefit(%arg0 : i32) -> i32 {
%0 = "test.op_d"(%arg0) : (i32) -> i32 %0 = "test.op_d"(%arg0) : (i32) -> i32
%1 = "test.op_g"(%arg0) : (i32) -> i32 %1 = "test.op_g"(%arg0) : (i32) -> i32
%2 = "test.op_g"(%1) : (i32) -> i32 %2 = "test.op_g"(%1) : (i32) -> i32
// CHECK: "test.op_f"(%arg0) // CHECK: "test.op_f"(%arg0)
// CHECK: "test.op_b"(%arg0) {attr = 34 : i32} // CHECK: "test.op_b"(%arg0) {attr = 20 : i32}
return %0 : i32 return %0 : i32
} }
// CHECK-LABEL: verifyNativeCodeCall // CHECK-LABEL: verifyNativeCodeCall
func @verifyNativeCodeCall(%arg0: i32, %arg1: i32) -> (i32, i32) { func @verifyNativeCodeCall(%arg0: i32, %arg1: i32) -> (i32, i32) {
// CHECK: %0 = "test.native_code_call2"(%arg0) {attr = [42, 24]} : (i32) -> i32 // CHECK: %0 = "test.native_code_call2"(%arg0) {attr = [42, 24]} : (i32) -> i32
// CHECK: return %0, %arg1 // CHECK: return %0, %arg1
%0 = "test.native_code_call1"(%arg0, %arg1) {choice = true, attr1 = 42, attr2 = 24} : (i32, i32) -> (i32) %0 = "test.native_code_call1"(%arg0, %arg1) {choice = true, attr1 = 42, attr2 = 24} : (i32, i32) -> (i32)
▲ Show 20 Lines • Show All 419 Lines • Show Last 20 Lines