This is an archive of the discontinued LLVM Phabricator instance.

Differential D134900

[mlir][Pass] Include anchor op in -pass-pipeline
ClosedPublic

Authored by rkayaith on Sep 29 2022, 1:16 PM.

Details

Reviewers
rriddle
mehdi_amini
bondhugula
antiagainst
nicolasvasilache
herhut
aartbik
ftynse
ThomasRaoux
dcaballe
Commits
rG13bd41096286: [mlir][Pass] Include anchor op in -pass-pipeline
Summary

In D134622 the printed form of a pass manager is changed to include the
name of the op that the pass manager is anchored on. This updates the
-pass-pipeline argument format to include the anchor op as well, so
that the printed form of a pipeline can be directly passed to
-pass-pipeline. In most cases this requires updating
-pass-pipeline='pipeline' to
-pass-pipeline='builtin.module(pipeline)'.

This also fixes an outdated assert that prevented running a
PassManager anchored on 'any'.

I've split out the mechanical test updates into D136193, but will
combine them into one commit before landing.

Diff Detail

Event Timeline

rkayaith created this revision.Sep 29 2022, 1:16 PM
Herald added a reviewer: rriddle. · View Herald TranscriptSep 29 2022, 1:16 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: zero9178, bzcheeseman, sdasgup3 and 19 others. · View Herald Transcript
Harbormaster completed remote builds in B189489: Diff 464006.Sep 29 2022, 1:17 PM
rkayaith edited parent revisions, added: D134622: [mlir] Include anchor op when printing pass managers; removed: D133645: [mlir-opt] Support parsing operations other than 'builtin.module' as top-level.Sep 29 2022, 1:17 PM
rkayaith mentioned this in D134622: [mlir] Include anchor op when printing pass managers.Sep 29 2022, 1:33 PM
rkayaith updated this revision to Diff 464821.Oct 3 2022, 2:36 PM
rkayaith added a parent revision: D133645: [mlir-opt] Support parsing operations other than 'builtin.module' as top-level.

update

Harbormaster completed remote builds in B190068: Diff 464821.Oct 3 2022, 2:36 PM
rkayaith updated this revision to Diff 464827.Oct 3 2022, 2:55 PM
rkayaith edited the summary of this revision. (Show Details)

update description

rkayaith removed a parent revision: D133645: [mlir-opt] Support parsing operations other than 'builtin.module' as top-level.Oct 3 2022, 2:55 PM
rkayaith updated this revision to Diff 464836.Oct 3 2022, 3:09 PM

update

rkayaith updated this revision to Diff 464844.Oct 3 2022, 3:42 PM

add extra test

rkayaith published this revision for review.Oct 3 2022, 3:44 PM
rkayaith added a reviewer: mehdi_amini.
Herald added a project: Restricted Project. · View Herald TranscriptOct 3 2022, 3:44 PM
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
Harbormaster completed remote builds in B190087: Diff 464844.Oct 3 2022, 4:52 PM
rkayaith updated this revision to Diff 465125.Oct 4 2022, 12:56 PM
rkayaith edited the summary of this revision. (Show Details)

add more info to description

rkayaith added a reviewer: bondhugula.Oct 4 2022, 12:57 PM

The approach used here currently (add a new option instead of changing pass-pipeline) has the downside that pass-pipeline used to be symmetric with the printed form, but no longer is. If we wanted to preserve that, some options I see:

Any thoughts on how to proceed here?

Harbormaster completed remote builds in B190287: Diff 465125.Oct 4 2022, 1:09 PM
rriddle added a comment.Oct 4 2022, 10:30 PM
In D134900#3834645, @rkayaith wrote:

The approach used here currently (add a new option instead of changing pass-pipeline) has the downside that pass-pipeline used to be symmetric with the printed form, but no longer is. If we wanted to preserve that, some options I see:

Any thoughts on how to proceed here?

I think we should proceed with changing -pass-pipeline. I'd rather have fewer things than more things. We've also already had people confused on the implicit nature of the anchor op in pass-pipeline before, and it seems better to just have that option represent the full pipeline.

mehdi_amini added a comment.Oct 5 2022, 11:04 AM

I'm aligned with River on the goal here.

rkayaith mentioned this in D135745: [mlir][Pass] Disallow mixing -pass-pipeline with other pass options.Oct 11 2022, 9:52 PM
rkayaith updated this revision to Diff 467025.Oct 11 2022, 10:49 PM
rkayaith retitled this revision from [mlir-opt] Add a '-pass-manager' option to [mlir][Pass] Include anchor op in -pass-pipeline.
rkayaith edited the summary of this revision. (Show Details)
rkayaith added a parent revision: D135745: [mlir][Pass] Disallow mixing -pass-pipeline with other pass options.

Rework patch to change the -pass-pipeline option instead. Other than
pipeline-parsing.mlir all the test updates here are mechanical
(`-pass-pipeline='pipeline' -> -pass-pipeline='builtin.module(pipeline)')

Herald added a reviewer: antiagainst. · View Herald TranscriptOct 11 2022, 10:49 PM
Herald added a reviewer: nicolasvasilache. · View Herald Transcript
Herald added a reviewer: herhut. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: ftynse. · View Herald Transcript
Herald added a reviewer: ThomasRaoux. · View Herald Transcript
Herald added a reviewer: dcaballe. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: ThomasRaoux, awarzynski, armkevincheng and 6 others. · View Herald Transcript
Harbormaster completed remote builds in B191658: Diff 467025.Oct 11 2022, 10:50 PM
Herald added a subscriber: jdoerfert. · View Herald TranscriptOct 11 2022, 10:50 PM
rkayaith removed a parent revision: D134622: [mlir] Include anchor op when printing pass managers.Oct 11 2022, 10:54 PM
rriddle added a comment.Oct 12 2022, 12:00 AM

Did you also scrub the docs for uses of pass-pipeline?

mlir/lib/Pass/Pass.cpp
780–785

Please avoid using if initializers with nullable things. Can you also spell out auto here?

rkayaith updated this revision to Diff 467225.Oct 12 2022, 12:20 PM
rkayaith marked an inline comment as done.

rebase, update docs, address comment

Harbormaster completed remote builds in B191793: Diff 467225.Oct 12 2022, 12:21 PM
rkayaith updated this revision to Diff 467274.Oct 12 2022, 3:11 PM

unnecessary 'llvm::'

Harbormaster completed remote builds in B191824: Diff 467274.Oct 12 2022, 3:12 PM
rkayaith updated this revision to Diff 468697.Oct 18 2022, 2:21 PM
rkayaith edited the summary of this revision. (Show Details)

move mechanical test updates into a separate diff

rkayaith edited parent revisions, added: D136193: Test updates for D134900; removed: D135745: [mlir][Pass] Disallow mixing -pass-pipeline with other pass options.Oct 18 2022, 2:21 PM
Harbormaster completed remote builds in B192849: Diff 468697.Oct 18 2022, 2:43 PM
rriddle accepted this revision.Oct 20 2022, 6:09 PM
This revision is now accepted and ready to land.Oct 20 2022, 6:09 PM
rkayaith updated this revision to Diff 471202.Oct 27 2022, 9:55 AM

rebase

Harbormaster completed remote builds in B194690: Diff 471202.Oct 27 2022, 11:25 AM
rkayaith mentioned this in rG0c36a1569a06: [mlir][Pass] Disallow mixing -pass-pipeline with other pass options.Nov 2 2022, 9:17 AM
Closed by commit rG13bd41096286: [mlir][Pass] Include anchor op in -pass-pipeline (authored by rkayaith). · Explain WhyNov 3 2022, 8:36 AM
This revision was automatically updated to reflect the committed changes.
rkayaith added a commit: rG13bd41096286: [mlir][Pass] Include anchor op in -pass-pipeline.
Herald added a subscriber: Moerafaat. · View Herald TranscriptNov 3 2022, 8:36 AM
rkayaith mentioned this in D136193: Test updates for D134900.Nov 3 2022, 10:42 AM
Renaud-K mentioned this in D136889: Infrastructure for alias analysis in flang.Nov 4 2022, 12:12 PM

Revision Contents

PathSize
flang/
test/
Fir/
2 lines
mlir/
docs/
14 lines
include/
mlir/
Pass/
1 line
lib/
Pass/
14 lines
4 lines
test/
Analysis/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Conversion/
AffineToStandard/
2 lines
ArithToLLVM/
2 lines
2 lines
ComplexToStandard/
2 lines
FuncToLLVM/
4 lines
4 lines
MathToFuncs/
2 lines
MathToLLVM/
2 lines
MemRefToLLVM/
4 lines
SCFToGPU/
4 lines
4 lines
2 lines
ShapeToStandard/
2 lines
TosaToLinalg/
2 lines
2 lines
2 lines
VectorToGPU/
4 lines
2 lines
VectorToSCF/
2 lines
2 lines
2 lines
2 lines
4 lines
Dialect/
Affine/
2 lines
2 lines
2 lines
ControlFlow/
2 lines
GPU/
2 lines
LLVMIR/
2 lines
Linalg/
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
NVGPU/
2 lines
Quant/
2 lines
SCF/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
SPIRV/
Transforms/
2 lines
2 lines
Vector/
2 lines
IR/
2 lines
2 lines
2 lines
Integration/
Dialect/
Linalg/
CPU/
6 lines
Standard/
CPU/
2 lines
Vector/
CPU/
8 lines
8 lines
8 lines
4 lines
4 lines
GPU/
CUDA/
2 lines
6 lines
GPU/
CUDA/
TensorCore/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ROCM/
2 lines
2 lines
2 lines
2 lines
2 lines
Pass/
2 lines
6 lines
2 lines
4 lines
8 lines
2 lines
2 lines
2 lines
12 lines
2 lines
2 lines
14 lines
8 lines
14 lines
16 lines
4 lines
Target/
LLVMIR/
2 lines
2 lines
Transforms/
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
6 lines
4 lines
2 lines
2 lines
mlir-cpu-runner/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
mlir-opt/
2 lines

Diff 472952

flang/test/Fir/cg-ops.fir

// RUN: fir-opt --split-input-file --pass-pipeline="cg-rewrite,cse" %s | FileCheck %s // RUN: fir-opt --split-input-file --pass-pipeline="builtin.module(cg-rewrite,cse)" %s | FileCheck %s
// CHECK-LABEL: func @codegen( // CHECK-LABEL: func @codegen(
// CHECK-SAME: %[[arg:.*]]: !fir // CHECK-SAME: %[[arg:.*]]: !fir
func.func @codegen(%addr : !fir.ref<!fir.array<?xi32>>) { func.func @codegen(%addr : !fir.ref<!fir.array<?xi32>>) {
// CHECK: %[[zero:.*]] = arith.constant 0 : index // CHECK: %[[zero:.*]] = arith.constant 0 : index
%0 = arith.constant 0 : index %0 = arith.constant 0 : index
%1 = fir.shape_shift %0, %0 : (index, index) -> !fir.shapeshift<1> %1 = fir.shape_shift %0, %0 : (index, index) -> !fir.shapeshift<1>
%2 = fir.slice %0, %0, %0 : (index, index, index) -> !fir.slice<1> %2 = fir.slice %0, %0, %0 : (index, index, index) -> !fir.slice<1>
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

mlir/docs/PassManagement.md

Show First 20 Lines • Show All 596 Lines • ▼ Show 20 Lines
``` ```
The collected statistics may be aggregated in two types of views: The collected statistics may be aggregated in two types of views:
A pipeline view that models the structure of the pass manager, this is the A pipeline view that models the structure of the pass manager, this is the
default view: default view:
```shell ```shell
$ mlir-opt -pass-pipeline='func.func(my-pass,my-pass)' foo.mlir -mlir-pass-statistics $ mlir-opt -pass-pipeline='any(func.func(my-pass,my-pass))' foo.mlir -mlir-pass-statistics
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
... Pass statistics report ... ... Pass statistics report ...
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
'func.func' Pipeline 'func.func' Pipeline
MyPass MyPass
(S) 15 exampleStat - An example statistic (S) 15 exampleStat - An example statistic
VerifierPass VerifierPass
MyPass MyPass
(S) 6 exampleStat - An example statistic (S) 6 exampleStat - An example statistic
VerifierPass VerifierPass
VerifierPass VerifierPass
``` ```
A list view that aggregates the statistics of all instances of a specific pass A list view that aggregates the statistics of all instances of a specific pass
together: together:
```shell ```shell
$ mlir-opt -pass-pipeline='func.func(my-pass, my-pass)' foo.mlir -mlir-pass-statistics -mlir-pass-statistics-display=list $ mlir-opt -pass-pipeline='any(func.func(my-pass,my-pass))' foo.mlir -mlir-pass-statistics -mlir-pass-statistics-display=list
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
... Pass statistics report ... ... Pass statistics report ...
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
MyPass MyPass
(S) 21 exampleStat - An example statistic (S) 21 exampleStat - An example statistic
``` ```
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines
```shell ```shell
$ mlir-opt foo.mlir -cse -canonicalize -convert-func-to-llvm='use-bare-ptr-memref-call-conv=1' $ mlir-opt foo.mlir -cse -canonicalize -convert-func-to-llvm='use-bare-ptr-memref-call-conv=1'
``` ```
Can also be specified as (via the `-pass-pipeline` flag): Can also be specified as (via the `-pass-pipeline` flag):
```shell ```shell
# Anchor the cse and canonicalize passes on the `func.func` operation. # Anchor the cse and canonicalize passes on the `func.func` operation.
$ mlir-opt foo.mlir -pass-pipeline='func.func(cse,canonicalize),convert-func-to-llvm{use-bare-ptr-memref-call-conv=1}' $ mlir-opt foo.mlir -pass-pipeline='builtin.module(func.func(cse,canonicalize),convert-func-to-llvm{use-bare-ptr-memref-call-conv=1})'
# Anchor the cse and canonicalize passes on "any" viable root operation. # Anchor the cse and canonicalize passes on "any" viable root operation.
$ mlir-opt foo.mlir -pass-pipeline='any(cse,canonicalize),convert-func-to-llvm{use-bare-ptr-memref-call-conv=1}' $ mlir-opt foo.mlir -pass-pipeline='builtin.module(any(cse,canonicalize),convert-func-to-llvm{use-bare-ptr-memref-call-conv=1})'
``` ```
In order to support round-tripping a pass to the textual representation using In order to support round-tripping a pass to the textual representation using
`OpPassManager::printAsTextualPipeline(raw_ostream&)`, override `StringRef `OpPassManager::printAsTextualPipeline(raw_ostream&)`, override `StringRef
Pass::getArgument()` to specify the argument used when registering a pass. Pass::getArgument()` to specify the argument used when registering a pass.
## Declarative Pass Specification ## Declarative Pass Specification
▲ Show 20 Lines • Show All 351 Lines • ▼ Show 20 Lines
In this mode, the results are displayed in a list sorted by total time with each In this mode, the results are displayed in a list sorted by total time with each
pass/analysis instance aggregated into one unique result. This view is useful pass/analysis instance aggregated into one unique result. This view is useful
for getting an overview of what analyses/passes are taking the most time in a for getting an overview of what analyses/passes are taking the most time in a
pipeline. This display mode is available in mlir-opt via pipeline. This display mode is available in mlir-opt via
`-mlir-timing-display=list`. `-mlir-timing-display=list`.
```shell ```shell
$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='func.func(cse,canonicalize)' -convert-func-to-llvm -mlir-timing -mlir-timing-display=list $ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='builtin.module(func.func(cse,canonicalize),convert-func-to-llvm)' -mlir-timing -mlir-timing-display=list
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
... Pass execution timing report ... ... Pass execution timing report ...
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
Total Execution Time: 0.0203 seconds Total Execution Time: 0.0203 seconds
---Wall Time--- --- Name --- ---Wall Time--- --- Name ---
0.0047 ( 55.9%) Canonicalizer 0.0047 ( 55.9%) Canonicalizer
0.0019 ( 22.2%) VerifierPass 0.0019 ( 22.2%) VerifierPass
0.0016 ( 18.5%) LLVMLoweringPass 0.0016 ( 18.5%) LLVMLoweringPass
0.0003 ( 3.4%) CSE 0.0003 ( 3.4%) CSE
0.0002 ( 1.9%) (A) DominanceInfo 0.0002 ( 1.9%) (A) DominanceInfo
0.0084 (100.0%) Total 0.0084 (100.0%) Total
``` ```
##### Tree Display Mode ##### Tree Display Mode
In this mode, the results are displayed in a nested pipeline view that mirrors In this mode, the results are displayed in a nested pipeline view that mirrors
the internal pass pipeline that is being executed in the pass manager. This view the internal pass pipeline that is being executed in the pass manager. This view
is useful for understanding specifically which parts of the pipeline are taking is useful for understanding specifically which parts of the pipeline are taking
the most time, and can also be used to identify when analyses are being the most time, and can also be used to identify when analyses are being
invalidated and recomputed. This is the default display mode. invalidated and recomputed. This is the default display mode.
```shell ```shell
$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='func.func(cse,canonicalize)' -convert-func-to-llvm -mlir-timing $ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='builtin.module(func.func(cse,canonicalize),convert-func-to-llvm)' -mlir-timing
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
... Pass execution timing report ... ... Pass execution timing report ...
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
Total Execution Time: 0.0249 seconds Total Execution Time: 0.0249 seconds
---Wall Time--- --- Name --- ---Wall Time--- --- Name ---
0.0058 ( 70.8%) 'func.func' Pipeline 0.0058 ( 70.8%) 'func.func' Pipeline
Show All 14 Lines
slightly changes. First, a new timing column is added, `User Time`, that slightly changes. First, a new timing column is added, `User Time`, that
displays the total time spent across all threads. Secondly, the `Wall Time` displays the total time spent across all threads. Secondly, the `Wall Time`
column displays the longest individual time spent amongst all of the threads. column displays the longest individual time spent amongst all of the threads.
This means that the `Wall Time` column will continue to give an indicator on the This means that the `Wall Time` column will continue to give an indicator on the
perceived time, or clock time, whereas the `User Time` will display the total perceived time, or clock time, whereas the `User Time` will display the total
cpu time. cpu time.
```shell ```shell
$ mlir-opt foo.mlir -pass-pipeline='func.func(cse,canonicalize)' -convert-func-to-llvm -mlir-timing $ mlir-opt foo.mlir -pass-pipeline='builtin.module(func.func(cse,canonicalize),convert-func-to-llvm)' -mlir-timing
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
... Pass execution timing report ... ... Pass execution timing report ...
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
Total Execution Time: 0.0078 seconds Total Execution Time: 0.0078 seconds
---User Time--- ---Wall Time--- --- Name --- ---User Time--- ---Wall Time--- --- Name ---
0.0177 ( 88.5%) 0.0057 ( 71.3%) 'func.func' Pipeline 0.0177 ( 88.5%) 0.0057 ( 71.3%) 'func.func' Pipeline
▲ Show 20 Lines • Show All 192 Lines • Show Last 20 Lines

mlir/include/mlir/Pass/PassManager.h

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Linespublic:
/// Construct a new pass manager with the given anchor operation type and /// Construct a new pass manager with the given anchor operation type and
/// nesting behavior. /// nesting behavior.
OpPassManager(StringRef name, Nesting nesting = Nesting::Explicit); OpPassManager(StringRef name, Nesting nesting = Nesting::Explicit);
OpPassManager(OperationName name, Nesting nesting = Nesting::Explicit); OpPassManager(OperationName name, Nesting nesting = Nesting::Explicit);
OpPassManager(OpPassManager &&rhs); OpPassManager(OpPassManager &&rhs);
OpPassManager(const OpPassManager &rhs); OpPassManager(const OpPassManager &rhs);
~OpPassManager(); ~OpPassManager();
OpPassManager &operator=(const OpPassManager &rhs); OpPassManager &operator=(const OpPassManager &rhs);
OpPassManager &operator=(OpPassManager &&rhs);
/// Iterator over the passes in this pass manager. /// Iterator over the passes in this pass manager.
using pass_iterator = using pass_iterator =
llvm::pointee_iterator<MutableArrayRef<std::unique_ptr<Pass>>::iterator>; llvm::pointee_iterator<MutableArrayRef<std::unique_ptr<Pass>>::iterator>;
pass_iterator begin(); pass_iterator begin();
pass_iterator end(); pass_iterator end();
iterator_range<pass_iterator> getPasses() { return {begin(), end()}; } iterator_range<pass_iterator> getPasses() { return {begin(), end()}; }
▲ Show 20 Lines • Show All 381 Lines • Show Last 20 Lines

mlir/lib/Pass/Pass.cpp

Show First 20 Lines • Show All 284 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
OpPassManager::OpPassManager(Nesting nesting) OpPassManager::OpPassManager(Nesting nesting)
: impl(new OpPassManagerImpl(nesting)) {} : impl(new OpPassManagerImpl(nesting)) {}
OpPassManager::OpPassManager(StringRef name, Nesting nesting) OpPassManager::OpPassManager(StringRef name, Nesting nesting)
: impl(new OpPassManagerImpl(name, nesting)) {} : impl(new OpPassManagerImpl(name, nesting)) {}
OpPassManager::OpPassManager(OperationName name, Nesting nesting) OpPassManager::OpPassManager(OperationName name, Nesting nesting)
: impl(new OpPassManagerImpl(name, nesting)) {} : impl(new OpPassManagerImpl(name, nesting)) {}
OpPassManager::OpPassManager(OpPassManager &&rhs) : impl(std::move(rhs.impl)) {} OpPassManager::OpPassManager(OpPassManager &&rhs) { *this = std::move(rhs); }
OpPassManager::OpPassManager(const OpPassManager &rhs) { *this = rhs; } OpPassManager::OpPassManager(const OpPassManager &rhs) { *this = rhs; }
OpPassManager &OpPassManager::operator=(const OpPassManager &rhs) { OpPassManager &OpPassManager::operator=(const OpPassManager &rhs) {
impl = std::make_unique<OpPassManagerImpl>(*rhs.impl); impl = std::make_unique<OpPassManagerImpl>(*rhs.impl);
return *this; return *this;
} }
OpPassManager &OpPassManager::operator=(OpPassManager &&rhs) {
impl = std::move(rhs.impl);
return *this;
}
OpPassManager::~OpPassManager() = default; OpPassManager::~OpPassManager() = default;
OpPassManager::pass_iterator OpPassManager::begin() { OpPassManager::pass_iterator OpPassManager::begin() {
return MutableArrayRef<std::unique_ptr<Pass>>{impl->passes}.begin(); return MutableArrayRef<std::unique_ptr<Pass>>{impl->passes}.begin();
} }
OpPassManager::pass_iterator OpPassManager::end() { OpPassManager::pass_iterator OpPassManager::end() {
return MutableArrayRef<std::unique_ptr<Pass>>{impl->passes}.end(); return MutableArrayRef<std::unique_ptr<Pass>>{impl->passes}.end();
▲ Show 20 Lines • Show All 461 Lines • ▼ Show 20 Lines
PassManager::~PassManager() = default; PassManager::~PassManager() = default;
void PassManager::enableVerifier(bool enabled) { verifyPasses = enabled; } void PassManager::enableVerifier(bool enabled) { verifyPasses = enabled; }
/// Run the passes within this manager on the provided operation. /// Run the passes within this manager on the provided operation.
LogicalResult PassManager::run(Operation *op) { LogicalResult PassManager::run(Operation *op) {
MLIRContext *context = getContext(); MLIRContext *context = getContext();
assert(op->getName() == getOpName(*context) && Optional<OperationName> anchorOp = getOpName(*context);
"operation has a different name than the PassManager or is from a " if (anchorOp && anchorOp != op->getName())
"different context"); return emitError(op->getLoc())
<< "can't run '" << getOpAnchorName() << "' pass manager on '"
<< op->getName() << "' op";
rriddleUnsubmitted
Done
ReplyInline Actions

Please avoid using if initializers with nullable things. Can you also spell out auto here?

rriddle: Please avoid using if initializers with nullable things. Can you also spell out auto here?
// Register all dialects for the current pipeline. // Register all dialects for the current pipeline.
DialectRegistry dependentDialects; DialectRegistry dependentDialects;
getDependentDialects(dependentDialects); getDependentDialects(dependentDialects);
context->appendDialectRegistry(dependentDialects); context->appendDialectRegistry(dependentDialects);
for (StringRef name : dependentDialects.getDialectNames()) for (StringRef name : dependentDialects.getDialectNames())
context->getOrLoadDialect(name); context->getOrLoadDialect(name);
// Before running, make sure to finalize the pipeline pass list. // Before running, make sure to finalize the pipeline pass list.
▲ Show 20 Lines • Show All 206 Lines • Show Last 20 Lines

mlir/lib/Pass/PassRegistry.cpp

Show First 20 Lines • Show All 917 Lines • ▼ Show 20 LinesLogicalResult PassPipelineCLParser::addToPipeline(
function_ref<LogicalResult(const Twine &)> errorHandler) const { function_ref<LogicalResult(const Twine &)> errorHandler) const {
if (passPipeline.getNumOccurrences()) { if (passPipeline.getNumOccurrences()) {
if (impl->passList.getNumOccurrences()) if (impl->passList.getNumOccurrences())
return errorHandler( return errorHandler(
"'-" + passPipelineArg + "'-" + passPipelineArg +
"' option can't be used with individual pass options"); "' option can't be used with individual pass options");
std::string errMsg; std::string errMsg;
llvm::raw_string_ostream os(errMsg); llvm::raw_string_ostream os(errMsg);
if (failed(parsePassPipeline(passPipeline, pm, os))) FailureOr<OpPassManager> parsed = parsePassPipeline(passPipeline, os);
if (failed(parsed))
return errorHandler(errMsg); return errorHandler(errMsg);
pm = std::move(*parsed);
return success(); return success();
} }
for (auto &passIt : impl->passList) { for (auto &passIt : impl->passList) {
if (failed(passIt.registryEntry->addToPipeline(pm, passIt.options, if (failed(passIt.registryEntry->addToPipeline(pm, passIt.options,
errorHandler))) errorHandler)))
return failure(); return failure();
} }
Show All 24 Lines

mlir/test/Analysis/test-alias-analysis-modref.mlir

// RUN: mlir-opt %s -pass-pipeline='func.func(test-alias-analysis-modref)' -split-input-file -allow-unregistered-dialect 2>&1 | FileCheck %s // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(test-alias-analysis-modref))' -split-input-file -allow-unregistered-dialect 2>&1 | FileCheck %s
// CHECK-LABEL: Testing : "no_side_effects" // CHECK-LABEL: Testing : "no_side_effects"
// CHECK: alloc -> func.region0#0: NoModRef // CHECK: alloc -> func.region0#0: NoModRef
// CHECK: dealloc -> func.region0#0: NoModRef // CHECK: dealloc -> func.region0#0: NoModRef
// CHECK: return -> func.region0#0: NoModRef // CHECK: return -> func.region0#0: NoModRef
func.func @no_side_effects(%arg: memref<2xf32>) attributes {test.ptr = "func"} { func.func @no_side_effects(%arg: memref<2xf32>) attributes {test.ptr = "func"} {
%1 = memref.alloc() {test.ptr = "alloc"} : memref<8x64xf32> %1 = memref.alloc() {test.ptr = "alloc"} : memref<8x64xf32>
memref.dealloc %1 {test.ptr = "dealloc"} : memref<8x64xf32> memref.dealloc %1 {test.ptr = "dealloc"} : memref<8x64xf32>
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

mlir/test/Analysis/test-alias-analysis.mlir

// RUN: mlir-opt %s -pass-pipeline='func.func(test-alias-analysis)' -split-input-file -allow-unregistered-dialect 2>&1 | FileCheck %s // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(test-alias-analysis))' -split-input-file -allow-unregistered-dialect 2>&1 | FileCheck %s
// CHECK-LABEL: Testing : "simple" // CHECK-LABEL: Testing : "simple"
// CHECK-DAG: func.region0#0 <-> func.region0#1: MayAlias // CHECK-DAG: func.region0#0 <-> func.region0#1: MayAlias
// CHECK-DAG: alloca_1#0 <-> alloca_2#0: NoAlias // CHECK-DAG: alloca_1#0 <-> alloca_2#0: NoAlias
// CHECK-DAG: alloca_1#0 <-> alloc_1#0: NoAlias // CHECK-DAG: alloca_1#0 <-> alloc_1#0: NoAlias
// CHECK-DAG: alloca_1#0 <-> alloc_2#0: NoAlias // CHECK-DAG: alloca_1#0 <-> alloc_2#0: NoAlias
// CHECK-DAG: alloca_1#0 <-> func.region0#0: NoAlias // CHECK-DAG: alloca_1#0 <-> func.region0#0: NoAlias
▲ Show 20 Lines • Show All 249 Lines • Show Last 20 Lines

mlir/test/Analysis/test-dominance.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(test-print-dominance)" -split-input-file 2>&1 | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(test-print-dominance))" -split-input-file 2>&1 | FileCheck %s
// CHECK-LABEL: Testing : func_condBranch // CHECK-LABEL: Testing : func_condBranch
func.func @func_condBranch(%cond : i1) { func.func @func_condBranch(%cond : i1) {
cf.cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
cf.br ^exit cf.br ^exit
^bb2: ^bb2:
cf.br ^exit cf.br ^exit
▲ Show 20 Lines • Show All 298 Lines • Show Last 20 Lines

mlir/test/Analysis/test-foo-analysis.mlir

// RUN: mlir-opt -split-input-file -pass-pipeline='func.func(test-foo-analysis)' %s 2>&1 | FileCheck %s // RUN: mlir-opt -split-input-file -pass-pipeline='builtin.module(func.func(test-foo-analysis))' %s 2>&1 | FileCheck %s
// CHECK-LABEL: function: @test_default_init // CHECK-LABEL: function: @test_default_init
func.func @test_default_init() -> () { func.func @test_default_init() -> () {
// CHECK: a -> 0 // CHECK: a -> 0
"test.foo"() {tag = "a"} : () -> () "test.foo"() {tag = "a"} : () -> ()
return return
} }
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

mlir/test/Analysis/test-liveness.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(test-print-liveness)" -split-input-file 2>&1 | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(test-print-liveness))" -split-input-file 2>&1 | FileCheck %s
// CHECK-LABEL: Testing : func_empty // CHECK-LABEL: Testing : func_empty
func.func @func_empty() { func.func @func_empty() {
// CHECK: Block: 0 // CHECK: Block: 0
// CHECK-NEXT: LiveIn:{{ *$}} // CHECK-NEXT: LiveIn:{{ *$}}
// CHECK-NEXT: LiveOut:{{ *$}} // CHECK-NEXT: LiveOut:{{ *$}}
// CHECK-NEXT: BeginLivenessIntervals // CHECK-NEXT: BeginLivenessIntervals
// CHECK-NEXT: EndLivenessIntervals // CHECK-NEXT: EndLivenessIntervals
▲ Show 20 Lines • Show All 486 Lines • Show Last 20 Lines

mlir/test/Analysis/test-match-reduction.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(test-match-reduction)" -verify-diagnostics -split-input-file // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(test-match-reduction))" -verify-diagnostics -split-input-file
// Verify that the generic reduction detection utility works on different // Verify that the generic reduction detection utility works on different
// dialects. // dialects.
// expected-remark@below {{Testing function}} // expected-remark@below {{Testing function}}
func.func @linalg_red_add(%in0t : tensor<?xf32>, %out0t : tensor<1xf32>) { func.func @linalg_red_add(%in0t : tensor<?xf32>, %out0t : tensor<1xf32>) {
// expected-remark@below {{Reduction found in output #0!}} // expected-remark@below {{Reduction found in output #0!}}
// expected-remark@below {{Reduced Value: <block argument> of type 'f32' at index: 0}} // expected-remark@below {{Reduced Value: <block argument> of type 'f32' at index: 0}}
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

mlir/test/Analysis/test-topoligical-sort.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(test-print-topological-sort)" 2>&1 | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(test-print-topological-sort))" 2>&1 | FileCheck %s
// CHECK-LABEL: Testing : region // CHECK-LABEL: Testing : region
// CHECK: arith.addi {{.*}} : index // CHECK: arith.addi {{.*}} : index
// CHECK-NEXT: scf.for // CHECK-NEXT: scf.for
// CHECK: } {__test_sort_original_idx__ = 2 : i64} // CHECK: } {__test_sort_original_idx__ = 2 : i64}
// CHECK-NEXT: arith.addi {{.*}} : i32 // CHECK-NEXT: arith.addi {{.*}} : i32
// CHECK-NEXT: arith.subi {{.*}} : i32 // CHECK-NEXT: arith.subi {{.*}} : i32
func.func @region( func.func @region(
Show All 12 Lines

mlir/test/Conversion/AffineToStandard/lower-affine-gpu.mlir

// RUN: mlir-opt -pass-pipeline="gpu.module(lower-affine)" %s | FileCheck %s // RUN: mlir-opt -pass-pipeline="builtin.module(gpu.module(lower-affine))" %s | FileCheck %s
#map0gpufunc = affine_map<(d0) -> (d0)> #map0gpufunc = affine_map<(d0) -> (d0)>
gpu.module @kernels { gpu.module @kernels {
gpu.func @foo(%arg0 : index, %arg1 : memref<?xf32>) -> f32 { gpu.func @foo(%arg0 : index, %arg1 : memref<?xf32>) -> f32 {
%0 = affine.apply #map0gpufunc(%arg0) %0 = affine.apply #map0gpufunc(%arg0)
%1 = memref.load %arg1[%0] : memref<?xf32> %1 = memref.load %arg1[%0] : memref<?xf32>
gpu.return %1 : f32 gpu.return %1 : f32
} }
// CHECK: gpu.func // CHECK: gpu.func
// CHECK-SAME: %[[ARG0:.*]]: index // CHECK-SAME: %[[ARG0:.*]]: index
// CHECK-NOT: affine.apply // CHECK-NOT: affine.apply
// CHECK: memref.load %{{.*}}[%[[ARG0]]] // CHECK: memref.load %{{.*}}[%[[ARG0]]]
} }

mlir/test/Conversion/ArithToLLVM/arith-to-llvm.mlir

// RUN: mlir-opt -pass-pipeline="func.func(convert-arith-to-llvm)" %s -split-input-file | FileCheck %s // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-arith-to-llvm))" %s -split-input-file | FileCheck %s
// CHECK-LABEL: @vector_ops // CHECK-LABEL: @vector_ops
func.func @vector_ops(%arg0: vector<4xf32>, %arg1: vector<4xi1>, %arg2: vector<4xi64>, %arg3: vector<4xi64>) -> vector<4xf32> { func.func @vector_ops(%arg0: vector<4xf32>, %arg1: vector<4xi1>, %arg2: vector<4xi64>, %arg3: vector<4xi64>) -> vector<4xf32> {
// CHECK-NEXT: %0 = llvm.mlir.constant(dense<4.200000e+01> : vector<4xf32>) : vector<4xf32> // CHECK-NEXT: %0 = llvm.mlir.constant(dense<4.200000e+01> : vector<4xf32>) : vector<4xf32>
%0 = arith.constant dense<42.> : vector<4xf32> %0 = arith.constant dense<42.> : vector<4xf32>
// CHECK-NEXT: %1 = llvm.fadd %arg0, %0 : vector<4xf32> // CHECK-NEXT: %1 = llvm.fadd %arg0, %0 : vector<4xf32>
%1 = arith.addf %arg0, %0 : vector<4xf32> %1 = arith.addf %arg0, %0 : vector<4xf32>
// CHECK-NEXT: %2 = llvm.sdiv %arg2, %arg2 : vector<4xi64> // CHECK-NEXT: %2 = llvm.sdiv %arg2, %arg2 : vector<4xi64>
▲ Show 20 Lines • Show All 458 Lines • Show Last 20 Lines

mlir/test/Conversion/ArithToLLVM/convert-nd-vector-to-llvmir.mlir

// RUN: mlir-opt -pass-pipeline="func.func(convert-arith-to-llvm)" %s -split-input-file | FileCheck %s // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-arith-to-llvm))" %s -split-input-file | FileCheck %s
// CHECK-LABEL: @vec_bin // CHECK-LABEL: @vec_bin
func.func @vec_bin(%arg0: vector<2x2x2xf32>) -> vector<2x2x2xf32> { func.func @vec_bin(%arg0: vector<2x2x2xf32>) -> vector<2x2x2xf32> {
// CHECK: llvm.mlir.undef : !llvm.array<2 x array<2 x vector<2xf32>>> // CHECK: llvm.mlir.undef : !llvm.array<2 x array<2 x vector<2xf32>>>
// This block appears 2x2 times // This block appears 2x2 times
// CHECK-NEXT: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<2 x array<2 x vector<2xf32>>> // CHECK-NEXT: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<2 x array<2 x vector<2xf32>>>
// CHECK-NEXT: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<2 x array<2 x vector<2xf32>>> // CHECK-NEXT: llvm.extractvalue %{{.*}}[0, 0] : !llvm.array<2 x array<2 x vector<2xf32>>>
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

mlir/test/Conversion/ComplexToStandard/full-conversion.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-complex-to-standard),convert-complex-to-llvm,func.func(convert-math-to-llvm,convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-complex-to-standard),convert-complex-to-llvm,func.func(convert-math-to-llvm,convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" | FileCheck %s
// CHECK-LABEL: llvm.func @complex_abs // CHECK-LABEL: llvm.func @complex_abs
// CHECK-SAME: %[[ARG:.*]]: ![[C_TY:.*]]) // CHECK-SAME: %[[ARG:.*]]: ![[C_TY:.*]])
func.func @complex_abs(%arg: complex<f32>) -> f32 { func.func @complex_abs(%arg: complex<f32>) -> f32 {
%abs = complex.abs %arg: complex<f32> %abs = complex.abs %arg: complex<f32>
return %abs : f32 return %abs : f32
} }
// CHECK: %[[REAL:.*]] = llvm.extractvalue %[[ARG]][0] : ![[C_TY]] // CHECK: %[[REAL:.*]] = llvm.extractvalue %[[ARG]][0] : ![[C_TY]]
Show All 36 Lines

mlir/test/Conversion/FuncToLLVM/func-memref.mlir

// RUN: mlir-opt -pass-pipeline="func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" -split-input-file %s | FileCheck %s // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" -split-input-file %s | FileCheck %s
// RUN: mlir-opt -pass-pipeline="func.func(convert-arith-to-llvm),convert-func-to-llvm{use-bare-ptr-memref-call-conv=1},reconcile-unrealized-casts" -split-input-file %s | FileCheck %s --check-prefix=BAREPTR // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-arith-to-llvm),convert-func-to-llvm{use-bare-ptr-memref-call-conv=1},reconcile-unrealized-casts)" -split-input-file %s | FileCheck %s --check-prefix=BAREPTR
// BAREPTR-LABEL: func @check_noalias // BAREPTR-LABEL: func @check_noalias
// BAREPTR-SAME: %{{.*}}: !llvm.ptr<f32> {llvm.noalias}, %{{.*}}: !llvm.ptr<f32> {llvm.noalias} // BAREPTR-SAME: %{{.*}}: !llvm.ptr<f32> {llvm.noalias}, %{{.*}}: !llvm.ptr<f32> {llvm.noalias}
func.func @check_noalias(%static : memref<2xf32> {llvm.noalias}, %other : memref<2xf32> {llvm.noalias}) { func.func @check_noalias(%static : memref<2xf32> {llvm.noalias}, %other : memref<2xf32> {llvm.noalias}) {
return return
} }
// ----- // -----
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

mlir/test/Conversion/FuncToLLVM/func-to-llvm.mlir

// RUN: mlir-opt -pass-pipeline="func.func(convert-math-to-llvm,convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" %s -split-input-file | FileCheck %s // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-math-to-llvm,convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" %s -split-input-file | FileCheck %s
// RUN: mlir-opt -pass-pipeline="func.func(convert-math-to-llvm,convert-arith-to-llvm{index-bitwidth=32}),convert-func-to-llvm{index-bitwidth=32},reconcile-unrealized-casts" %s -split-input-file | FileCheck --check-prefix=CHECK32 %s // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-math-to-llvm,convert-arith-to-llvm{index-bitwidth=32}),convert-func-to-llvm{index-bitwidth=32},reconcile-unrealized-casts)" %s -split-input-file | FileCheck --check-prefix=CHECK32 %s
// CHECK-LABEL: func @empty() { // CHECK-LABEL: func @empty() {
// CHECK-NEXT: llvm.return // CHECK-NEXT: llvm.return
// CHECK-NEXT: } // CHECK-NEXT: }
func.func @empty() { func.func @empty() {
^bb0: ^bb0:
return return
} }
▲ Show 20 Lines • Show All 529 Lines • Show Last 20 Lines

mlir/test/Conversion/MathToFuncs/math-to-funcs.mlir

// RUN: mlir-opt %s -split-input-file -pass-pipeline="convert-math-to-funcs" | FileCheck %s // RUN: mlir-opt %s -split-input-file -pass-pipeline="builtin.module(convert-math-to-funcs)" | FileCheck %s
// ----- // -----
// CHECK-LABEL: func @ipowi( // CHECK-LABEL: func @ipowi(
// CHECK-SAME: %[[ARG0:.+]]: i64, // CHECK-SAME: %[[ARG0:.+]]: i64,
// CHECK-SAME: %[[ARG1:.+]]: i64) // CHECK-SAME: %[[ARG1:.+]]: i64)
func.func @ipowi(%arg0: i64, %arg1: i64) { func.func @ipowi(%arg0: i64, %arg1: i64) {
// CHECK: call @__mlir_math_ipowi_i64(%[[ARG0]], %[[ARG1]]) : (i64, i64) -> i64 // CHECK: call @__mlir_math_ipowi_i64(%[[ARG0]], %[[ARG1]]) : (i64, i64) -> i64
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

mlir/test/Conversion/MathToLLVM/math-to-llvm.mlir

// RUN: mlir-opt %s -split-input-file -pass-pipeline="func.func(convert-math-to-llvm)" | FileCheck %s // RUN: mlir-opt %s -split-input-file -pass-pipeline="builtin.module(func.func(convert-math-to-llvm))" | FileCheck %s
// CHECK-LABEL: @ops // CHECK-LABEL: @ops
func.func @ops(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: i32, %arg4: f64) { func.func @ops(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: i32, %arg4: f64) {
// CHECK: = llvm.intr.exp(%{{.*}}) : (f32) -> f32 // CHECK: = llvm.intr.exp(%{{.*}}) : (f32) -> f32
%0 = math.exp %arg0 : f32 %0 = math.exp %arg0 : f32
// CHECK: = llvm.intr.exp2(%{{.*}}) : (f32) -> f32 // CHECK: = llvm.intr.exp2(%{{.*}}) : (f32) -> f32
%1 = math.exp2 %arg0 : f32 %1 = math.exp2 %arg0 : f32
// CHECK: = llvm.intr.sqrt(%{{.*}}) : (f32) -> f32 // CHECK: = llvm.intr.sqrt(%{{.*}}) : (f32) -> f32
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

mlir/test/Conversion/MemRefToLLVM/generic-functions.mlir

// RUN: mlir-opt -pass-pipeline="convert-memref-to-llvm{use-generic-functions=1}" -split-input-file %s \ // RUN: mlir-opt -pass-pipeline="builtin.module(convert-memref-to-llvm{use-generic-functions=1})" -split-input-file %s \
// RUN: | FileCheck %s --check-prefix="CHECK-NOTALIGNED" // RUN: | FileCheck %s --check-prefix="CHECK-NOTALIGNED"
// RUN: mlir-opt -pass-pipeline="convert-memref-to-llvm{use-generic-functions=1 use-aligned-alloc=1}" -split-input-file %s \ // RUN: mlir-opt -pass-pipeline="builtin.module(convert-memref-to-llvm{use-generic-functions=1 use-aligned-alloc=1})" -split-input-file %s \
// RUN: | FileCheck %s --check-prefix="CHECK-ALIGNED" // RUN: | FileCheck %s --check-prefix="CHECK-ALIGNED"
// CHECK-LABEL: func @alloc() // CHECK-LABEL: func @alloc()
func.func @zero_d_alloc() -> memref<f32> { func.func @zero_d_alloc() -> memref<f32> {
// CHECK-NOTALIGNED: llvm.call @_mlir_memref_to_llvm_alloc(%{{.*}}) : (i64) -> !llvm.ptr<i8> // CHECK-NOTALIGNED: llvm.call @_mlir_memref_to_llvm_alloc(%{{.*}}) : (i64) -> !llvm.ptr<i8>
// CHECK-ALIGNED: llvm.call @_mlir_memref_to_llvm_aligned_alloc(%{{.*}}, %{{.*}}) : (i64, i64) -> !llvm.ptr<i8> // CHECK-ALIGNED: llvm.call @_mlir_memref_to_llvm_aligned_alloc(%{{.*}}, %{{.*}}) : (i64, i64) -> !llvm.ptr<i8>
%0 = memref.alloc() : memref<f32> %0 = memref.alloc() : memref<f32>
return %0 : memref<f32> return %0 : memref<f32>
Show All 11 Lines

mlir/test/Conversion/SCFToGPU/no_blocks_no_threads.mlir

// RUN: mlir-opt -pass-pipeline="func.func(convert-affine-for-to-gpu{gpu-block-dims=0 gpu-thread-dims=1})" %s | FileCheck --check-prefix=CHECK-THREADS %s // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-affine-for-to-gpu{gpu-block-dims=0 gpu-thread-dims=1}))" %s | FileCheck --check-prefix=CHECK-THREADS %s
// RUN: mlir-opt -pass-pipeline="func.func(convert-affine-for-to-gpu{gpu-block-dims=1 gpu-thread-dims=0})" %s | FileCheck --check-prefix=CHECK-BLOCKS %s // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-affine-for-to-gpu{gpu-block-dims=1 gpu-thread-dims=0}))" %s | FileCheck --check-prefix=CHECK-BLOCKS %s
// CHECK-THREADS-LABEL: @one_d_loop // CHECK-THREADS-LABEL: @one_d_loop
// CHECK-BLOCKS-LABEL: @one_d_loop // CHECK-BLOCKS-LABEL: @one_d_loop
func.func @one_d_loop(%A : memref<?xf32>, %B : memref<?xf32>) { func.func @one_d_loop(%A : memref<?xf32>, %B : memref<?xf32>) {
// Bounds of the loop, its range and step. // Bounds of the loop, its range and step.
// CHECK-THREADS-NEXT: %{{.*}} = arith.constant 0 : index // CHECK-THREADS-NEXT: %{{.*}} = arith.constant 0 : index
// CHECK-THREADS-NEXT: %{{.*}} = arith.constant 42 : index // CHECK-THREADS-NEXT: %{{.*}} = arith.constant 42 : index
// CHECK-THREADS-NEXT: %[[BOUND:.*]] = arith.subi %{{.*}}, %{{.*}} : index // CHECK-THREADS-NEXT: %[[BOUND:.*]] = arith.subi %{{.*}}, %{{.*}} : index
Show All 24 Lines

mlir/test/Conversion/SCFToGPU/step_one.mlir

// RUN: mlir-opt -pass-pipeline="func.func(convert-affine-for-to-gpu{gpu-block-dims=1 gpu-thread-dims=1})" %s | FileCheck --check-prefix=CHECK-11 %s // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-affine-for-to-gpu{gpu-block-dims=1 gpu-thread-dims=1}))" %s | FileCheck --check-prefix=CHECK-11 %s
// RUN: mlir-opt -pass-pipeline="func.func(convert-affine-for-to-gpu{gpu-block-dims=2 gpu-thread-dims=2})" %s | FileCheck --check-prefix=CHECK-22 %s // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-affine-for-to-gpu{gpu-block-dims=2 gpu-thread-dims=2}))" %s | FileCheck --check-prefix=CHECK-22 %s
// CHECK-11-LABEL: @step_1 // CHECK-11-LABEL: @step_1
// CHECK-22-LABEL: @step_1 // CHECK-22-LABEL: @step_1
func.func @step_1(%A : memref<?x?x?x?xf32>, %B : memref<?x?x?x?xf32>) { func.func @step_1(%A : memref<?x?x?x?xf32>, %B : memref<?x?x?x?xf32>) {
// Bounds of the loop, its range and step. // Bounds of the loop, its range and step.
// CHECK-11-NEXT: %{{.*}} = arith.constant 0 : index // CHECK-11-NEXT: %{{.*}} = arith.constant 0 : index
// CHECK-11-NEXT: %{{.*}} = arith.constant 42 : index // CHECK-11-NEXT: %{{.*}} = arith.constant 42 : index
// CHECK-11-NEXT: %{{.*}} = arith.subi %{{.*}}, %{{.*}} : index // CHECK-11-NEXT: %{{.*}} = arith.subi %{{.*}}, %{{.*}} : index
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

mlir/test/Conversion/SCFToGPU/step_positive.mlir

// RUN: mlir-opt -pass-pipeline="func.func(convert-affine-for-to-gpu{gpu-block-dims=1 gpu-thread-dims=1})" %s | FileCheck %s // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-affine-for-to-gpu{gpu-block-dims=1 gpu-thread-dims=1}))" %s | FileCheck %s
// CHECK-LABEL: @step_var // CHECK-LABEL: @step_var
func.func @step_var(%A : memref<?x?xf32>, %B : memref<?x?xf32>) { func.func @step_var(%A : memref<?x?xf32>, %B : memref<?x?xf32>) {
// Check that we divide by step. // Check that we divide by step.
// CHECK: %[[range_i:.*]] = arith.divsi {{.*}}, %{{.*}} // CHECK: %[[range_i:.*]] = arith.divsi {{.*}}, %{{.*}}
// CHECK: %[[range_j:.*]] = arith.divsi {{.*}}, %{{.*}} // CHECK: %[[range_j:.*]] = arith.divsi {{.*}}, %{{.*}}
// CHECK: gpu.launch // CHECK: gpu.launch
Show All 19 Lines

mlir/test/Conversion/ShapeToStandard/convert-shape-constraints.mlir

// RUN: mlir-opt -pass-pipeline="func.func(convert-shape-constraints)" <%s | FileCheck %s // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-shape-constraints))" <%s | FileCheck %s
// There's not very much useful to check here other than pasting the output. // There's not very much useful to check here other than pasting the output.
// CHECK-LABEL: func @cstr_broadcastable( // CHECK-LABEL: func @cstr_broadcastable(
// CHECK-SAME: %[[LHS:.*]]: tensor<?xindex>, // CHECK-SAME: %[[LHS:.*]]: tensor<?xindex>,
// CHECK-SAME: %[[RHS:.*]]: tensor<?xindex>) -> !shape.witness { // CHECK-SAME: %[[RHS:.*]]: tensor<?xindex>) -> !shape.witness {
// CHECK: %[[RET:.*]] = shape.const_witness true // CHECK: %[[RET:.*]] = shape.const_witness true
// CHECK: %[[BROADCAST_IS_VALID:.*]] = shape.is_broadcastable %[[LHS]], %[[RHS]] // CHECK: %[[BROADCAST_IS_VALID:.*]] = shape.is_broadcastable %[[LHS]], %[[RHS]]
// CHECK: cf.assert %[[BROADCAST_IS_VALID]], "required broadcastable shapes" // CHECK: cf.assert %[[BROADCAST_IS_VALID]], "required broadcastable shapes"
Show All 28 Lines

mlir/test/Conversion/TosaToLinalg/tosa-to-linalg-named.mlir

// RUN: mlir-opt --split-input-file -pass-pipeline="func.func(tosa-to-linalg-named)" %s -verify-diagnostics -o -| FileCheck %s // RUN: mlir-opt --split-input-file -pass-pipeline="builtin.module(func.func(tosa-to-linalg-named))" %s -verify-diagnostics -o -| FileCheck %s
// CHECK-LABEL: @matmul // CHECK-LABEL: @matmul
func.func @matmul(%arg0: tensor<1x5x3xf32>, %arg1: tensor<1x3x6xf32>) -> (tensor<1x5x6xf32>) { func.func @matmul(%arg0: tensor<1x5x3xf32>, %arg1: tensor<1x3x6xf32>) -> (tensor<1x5x6xf32>) {
// CHECK: [[C0:%.+]] = arith.constant 0 // CHECK: [[C0:%.+]] = arith.constant 0
// CHECK: [[INIT:%.+]] = tensor.empty() // CHECK: [[INIT:%.+]] = tensor.empty()
// CHECK: [[FILLED:%.+]] = linalg.fill ins([[C0]] : f32) outs([[INIT]] : tensor<1x5x6xf32>) -> tensor<1x5x6xf32> // CHECK: [[FILLED:%.+]] = linalg.fill ins([[C0]] : f32) outs([[INIT]] : tensor<1x5x6xf32>) -> tensor<1x5x6xf32>
// CHECK: linalg.batch_matmul ins(%arg0, %arg1 : tensor<1x5x3xf32>, tensor<1x3x6xf32>) outs([[FILLED]] : tensor<1x5x6xf32>) -> tensor<1x5x6xf32> // CHECK: linalg.batch_matmul ins(%arg0, %arg1 : tensor<1x5x3xf32>, tensor<1x3x6xf32>) outs([[FILLED]] : tensor<1x5x6xf32>) -> tensor<1x5x6xf32>
%0 = "tosa.matmul"(%arg0, %arg1) : (tensor<1x5x3xf32>, tensor<1x3x6xf32>) -> (tensor<1x5x6xf32>) %0 = "tosa.matmul"(%arg0, %arg1) : (tensor<1x5x3xf32>, tensor<1x3x6xf32>) -> (tensor<1x5x6xf32>)
▲ Show 20 Lines • Show All 596 Lines • Show Last 20 Lines

mlir/test/Conversion/TosaToLinalg/tosa-to-linalg-resize.mlir

// RUN: mlir-opt --split-input-file -pass-pipeline="func.func(tosa-to-linalg)" %s -o -| FileCheck %s // RUN: mlir-opt --split-input-file -pass-pipeline="builtin.module(func.func(tosa-to-linalg))" %s -o -| FileCheck %s
// CHECK: #map = affine_map<(d0, d1, d2, d3) -> (d0, d3)> // CHECK: #map = affine_map<(d0, d1, d2, d3) -> (d0, d3)>
// CHECK: #map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)> // CHECK: #map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
// CHECK-LABEL: @broadcast_resize_nearest_fp // CHECK-LABEL: @broadcast_resize_nearest_fp
func.func @broadcast_resize_nearest_fp(%arg0 : tensor<3x1x1x7xf32>) -> tensor<3x15x13x7xf32> { func.func @broadcast_resize_nearest_fp(%arg0 : tensor<3x1x1x7xf32>) -> tensor<3x15x13x7xf32> {
// CHECK: %[[COLLAPSE:.+]] = tensor.collapse_shape %arg0 // CHECK: %[[COLLAPSE:.+]] = tensor.collapse_shape %arg0
// CHECK-SAME{literal}: [[0], [1, 2, 3]] // CHECK-SAME{literal}: [[0], [1, 2, 3]]
// CHECK: %[[EMPTY:.+]] = tensor.empty() : tensor<3x15x13x7xf32> // CHECK: %[[EMPTY:.+]] = tensor.empty() : tensor<3x15x13x7xf32>
▲ Show 20 Lines • Show All 477 Lines • Show Last 20 Lines

mlir/test/Conversion/TosaToLinalg/tosa-to-linalg.mlir

// RUN: mlir-opt --split-input-file -pass-pipeline="func.func(tosa-to-linalg)" %s -verify-diagnostics -o -| FileCheck %s // RUN: mlir-opt --split-input-file -pass-pipeline="builtin.module(func.func(tosa-to-linalg))" %s -verify-diagnostics -o -| FileCheck %s
// CHECK: #[[$MAP0:.*]] = affine_map<() -> ()> // CHECK: #[[$MAP0:.*]] = affine_map<() -> ()>
// CHECK-LABEL: @test_abs // CHECK-LABEL: @test_abs
// CHECK-SAME: (%[[ARG0:[0-9a-zA-Z_]*]] // CHECK-SAME: (%[[ARG0:[0-9a-zA-Z_]*]]
func.func @test_abs(%arg0: tensor<f32>) -> tensor<f32> { func.func @test_abs(%arg0: tensor<f32>) -> tensor<f32> {
// CHECK: [[INIT:%.+]] = tensor.empty() : tensor<f32> // CHECK: [[INIT:%.+]] = tensor.empty() : tensor<f32>
// CHECK: [[GENERIC:%.+]] = linalg.generic {indexing_maps = [#[[$MAP0]], #[[$MAP0]]], iterator_types = []} ins(%[[ARG0]] : tensor<f32>) outs([[INIT]] : tensor<f32>) { // CHECK: [[GENERIC:%.+]] = linalg.generic {indexing_maps = [#[[$MAP0]], #[[$MAP0]]], iterator_types = []} ins(%[[ARG0]] : tensor<f32>) outs([[INIT]] : tensor<f32>) {
▲ Show 20 Lines • Show All 1,648 Lines • Show Last 20 Lines

mlir/test/Conversion/VectorToGPU/vector-to-mma-ops-mma-sync.mlir

// RUN: mlir-opt %s -split-input-file -pass-pipeline="func.func(convert-vector-to-gpu{use-nvgpu=true})" | FileCheck %s // RUN: mlir-opt %s -split-input-file -pass-pipeline="builtin.module(func.func(convert-vector-to-gpu{use-nvgpu=true}))" | FileCheck %s
//######################################################### //#########################################################
// INT8 row-row-row // INT8 row-row-row
//######################################################### //#########################################################
// CHECK-DAG: [[$rowA0_map:#.+]] = affine_map<()[s0] -> (s0 mod 16 + 1)> // CHECK-DAG: [[$rowA0_map:#.+]] = affine_map<()[s0] -> (s0 mod 16 + 1)>
// CHECK-DAG: [[$colA0_map:#.+]] = affine_map<()[s0] -> ((s0 floordiv 16) * 16 + 1)> // CHECK-DAG: [[$colA0_map:#.+]] = affine_map<()[s0] -> ((s0 floordiv 16) * 16 + 1)>
▲ Show 20 Lines • Show All 649 Lines • ▼ Show 20 Linesfunc.func @m16n8k8_tf32_f32_col_col_row(%arg0: memref<20x20xf32, 3>, %arg1: memref<20x20xf32, 3>, %arg2: memref<20x20xf32>) {
// CHECK: affine.apply [[$colC_map]] // CHECK: affine.apply [[$colC_map]]
// CHECK: vector.store // CHECK: vector.store
// CHECK: vector.extract [[d_frag]][1] : vector<2x2xf32> // CHECK: vector.extract [[d_frag]][1] : vector<2x2xf32>
// CHECK: affine.apply [[$rowC8_map]] // CHECK: affine.apply [[$rowC8_map]]
// CHECK: affine.apply [[$colC_map]] // CHECK: affine.apply [[$colC_map]]
// CHECK: vector.store // CHECK: vector.store
vector.transfer_write %D, %arg2[%c16, %c8] {in_bounds = [true, true]} : vector<16x8xf32>, memref<20x20xf32> vector.transfer_write %D, %arg2[%c16, %c8] {in_bounds = [true, true]} : vector<16x8xf32>, memref<20x20xf32>
return return
} }
No newline at end of file

mlir/test/Conversion/VectorToGPU/vector-to-mma-ops.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-gpu),canonicalize" | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-gpu),canonicalize)" | FileCheck %s
#map0 = affine_map<(d0, d1) -> (d1, d0)> #map0 = affine_map<(d0, d1) -> (d1, d0)>
#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> #map1 = affine_map<(d0, d1, d2) -> (d0, d2)>
#map2 = affine_map<(d0, d1, d2) -> (d1, d2)> #map2 = affine_map<(d0, d1, d2) -> (d1, d2)>
#map3 = affine_map<(d0, d1, d2) -> (d0, d1)> #map3 = affine_map<(d0, d1, d2) -> (d0, d1)>
#map4 = affine_map<(d0) -> (d0, 0)> #map4 = affine_map<(d0) -> (d0, 0)>
// CHECK-LABEL: func @matmul // CHECK-LABEL: func @matmul
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

mlir/test/Conversion/VectorToSCF/tensor-transfer-ops.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{lower-tensors=true})" -split-input-file -allow-unregistered-dialect | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{lower-tensors=true}))" -split-input-file -allow-unregistered-dialect | FileCheck %s
// CHECK-LABEL: func @transfer_read_2d( // CHECK-LABEL: func @transfer_read_2d(
// CHECK: %[[ALLOC:.*]] = memref.alloca() : memref<vector<4x9xf32>> // CHECK: %[[ALLOC:.*]] = memref.alloca() : memref<vector<4x9xf32>>
// CHECK: %[[CASTED:.*]] = vector.type_cast %[[ALLOC]] : memref<vector<4x9xf32>> to memref<4xvector<9xf32>> // CHECK: %[[CASTED:.*]] = vector.type_cast %[[ALLOC]] : memref<vector<4x9xf32>> to memref<4xvector<9xf32>>
// CHECK: scf.for {{.*}} { // CHECK: scf.for {{.*}} {
// CHECK: %[[READ:.*]] = vector.transfer_read %{{.*}}[{{.*}}], %cst {in_bounds = [true]} : tensor<?x?xf32>, vector<9xf32> // CHECK: %[[READ:.*]] = vector.transfer_read %{{.*}}[{{.*}}], %cst {in_bounds = [true]} : tensor<?x?xf32>, vector<9xf32>
// CHECK: memref.store %[[READ]], %[[CASTED]][%{{.*}}] : memref<4xvector<9xf32>> // CHECK: memref.store %[[READ]], %[[CASTED]][%{{.*}}] : memref<4xvector<9xf32>>
// CHECK: } // CHECK: }
Show All 29 Lines

mlir/test/Conversion/VectorToSCF/unrolled-tensor-transfer-ops.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true lower-tensors=true})" -split-input-file -allow-unregistered-dialect | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true lower-tensors=true}))" -split-input-file -allow-unregistered-dialect | FileCheck %s
// CHECK-LABEL: func @transfer_read_2d( // CHECK-LABEL: func @transfer_read_2d(
// CHECK: %[[V_INIT:.*]] = arith.constant dense<-4.200000e+01> : vector<4x9xf32> // CHECK: %[[V_INIT:.*]] = arith.constant dense<-4.200000e+01> : vector<4x9xf32>
// CHECK: %[[V0:.*]] = vector.transfer_read %{{.*}}[{{.*}}], %{{.*}} {in_bounds = [true]} : tensor<?x?xf32>, vector<9xf32> // CHECK: %[[V0:.*]] = vector.transfer_read %{{.*}}[{{.*}}], %{{.*}} {in_bounds = [true]} : tensor<?x?xf32>, vector<9xf32>
// CHECK: %[[I0:.*]] = vector.insert %[[V0]], %[[V_INIT]] [0] : vector<9xf32> into vector<4x9xf32> // CHECK: %[[I0:.*]] = vector.insert %[[V0]], %[[V_INIT]] [0] : vector<9xf32> into vector<4x9xf32>
// CHECK: %[[V1:.*]] = vector.transfer_read %{{.*}}[{{.*}}], %{{.*}} {in_bounds = [true]} : tensor<?x?xf32>, vector<9xf32> // CHECK: %[[V1:.*]] = vector.transfer_read %{{.*}}[{{.*}}], %{{.*}} {in_bounds = [true]} : tensor<?x?xf32>, vector<9xf32>
// CHECK: %[[I1:.*]] = vector.insert %[[V1]], %[[I0]] [1] : vector<9xf32> into vector<4x9xf32> // CHECK: %[[I1:.*]] = vector.insert %[[V1]], %[[I0]] [1] : vector<9xf32> into vector<4x9xf32>
// CHECK: %[[V2:.*]] = vector.transfer_read %{{.*}}[{{.*}}], %{{.*}} {in_bounds = [true]} : tensor<?x?xf32>, vector<9xf32> // CHECK: %[[V2:.*]] = vector.transfer_read %{{.*}}[{{.*}}], %{{.*}} {in_bounds = [true]} : tensor<?x?xf32>, vector<9xf32>
Show All 27 Lines

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

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true})" -split-input-file -allow-unregistered-dialect | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true}))" -split-input-file -allow-unregistered-dialect | FileCheck %s
// CHECK-LABEL: func @transfer_read_inbounds // CHECK-LABEL: func @transfer_read_inbounds
func.func @transfer_read_inbounds(%A : memref<?x?x?xf32>) -> (vector<2x3x4xf32>) { func.func @transfer_read_inbounds(%A : memref<?x?x?xf32>) -> (vector<2x3x4xf32>) {
%f0 = arith.constant 0.0: f32 %f0 = arith.constant 0.0: f32
%c0 = arith.constant 0: index %c0 = arith.constant 0: index
// CHECK: vector.transfer_read {{.*}} : memref<?x?x?xf32>, vector<4xf32> // CHECK: vector.transfer_read {{.*}} : memref<?x?x?xf32>, vector<4xf32>
// CHECK-NEXT: vector.insert {{.*}} [0, 0] : vector<4xf32> into vector<2x3x4xf32> // CHECK-NEXT: vector.insert {{.*}} [0, 0] : vector<4xf32> into vector<2x3x4xf32>
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

mlir/test/Conversion/VectorToSCF/vector-to-scf-mask-and-permutation-map.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{lower-permutation-maps=true})" -split-input-file | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{lower-permutation-maps=true}))" -split-input-file | FileCheck %s
// Ensure that the permutation map is lowered (by inserting a transpose op) // Ensure that the permutation map is lowered (by inserting a transpose op)
// before lowering the vector.transfer_read. // before lowering the vector.transfer_read.
// CHECK-LABEL: func @transfer_read_2d_mask_transposed( // CHECK-LABEL: func @transfer_read_2d_mask_transposed(
// CHECK-DAG: %[[PADDING:.*]] = arith.constant dense<-4.200000e+01> : vector<9xf32> // CHECK-DAG: %[[PADDING:.*]] = arith.constant dense<-4.200000e+01> : vector<9xf32>
// CHECK-DAG: %[[MASK:.*]] = arith.constant dense<{{.*}}> : vector<9x4xi1> // CHECK-DAG: %[[MASK:.*]] = arith.constant dense<{{.*}}> : vector<9x4xi1>
// CHECK: %[[MASK_MEM:.*]] = memref.alloca() : memref<vector<4x9xi1>> // CHECK: %[[MASK_MEM:.*]] = memref.alloca() : memref<vector<4x9xi1>>
Show All 28 Lines

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

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf)" -split-input-file -allow-unregistered-dialect | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf))" -split-input-file -allow-unregistered-dialect | FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true})" -split-input-file -allow-unregistered-dialect | FileCheck %s --check-prefix=FULL-UNROLL // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true}))" -split-input-file -allow-unregistered-dialect | FileCheck %s --check-prefix=FULL-UNROLL
// CHECK-LABEL: func @vector_transfer_ops_0d( // CHECK-LABEL: func @vector_transfer_ops_0d(
func.func @vector_transfer_ops_0d(%M: memref<f32>) { func.func @vector_transfer_ops_0d(%M: memref<f32>) {
%f0 = arith.constant 0.0 : f32 %f0 = arith.constant 0.0 : f32
// 0-d transfers are left untouched by vector-to-scf. // 0-d transfers are left untouched by vector-to-scf.
// They are independently lowered to the proper memref.load/store. // They are independently lowered to the proper memref.load/store.
// CHECK: vector.transfer_read {{.*}}: memref<f32>, vector<f32> // CHECK: vector.transfer_read {{.*}}: memref<f32>, vector<f32>
▲ Show 20 Lines • Show All 492 Lines • Show Last 20 Lines

mlir/test/Dialect/Affine/canonicalize.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -pass-pipeline='func.func(canonicalize)' | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -pass-pipeline='builtin.module(func.func(canonicalize))' | FileCheck %s
// ----- // -----
// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0) -> (d0 - 1)> // CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0) -> (d0 - 1)>
// CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0) -> (d0 + 1)> // CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0) -> (d0 + 1)>
// CHECK-LABEL: func @compose_affine_maps_1dto2d_no_symbols() { // CHECK-LABEL: func @compose_affine_maps_1dto2d_no_symbols() {
func.func @compose_affine_maps_1dto2d_no_symbols() { func.func @compose_affine_maps_1dto2d_no_symbols() {
▲ Show 20 Lines • Show All 1,181 Lines • Show Last 20 Lines

mlir/test/Dialect/Affine/loop-unswitch.mlir

// RUN: mlir-opt %s -split-input-file -pass-pipeline="func.func(test-affine-loop-unswitch)" | FileCheck %s // RUN: mlir-opt %s -split-input-file -pass-pipeline="builtin.module(func.func(test-affine-loop-unswitch))" | FileCheck %s
// CHECK-DAG: #[[$SET:.*]] = affine_set<(d0) : (d0 - 2 >= 0)> // CHECK-DAG: #[[$SET:.*]] = affine_set<(d0) : (d0 - 2 >= 0)>
// CHECK-LABEL: func @if_else_imperfect // CHECK-LABEL: func @if_else_imperfect
func.func @if_else_imperfect(%A : memref<100xi32>, %B : memref<100xi32>, %v : i32) { func.func @if_else_imperfect(%A : memref<100xi32>, %B : memref<100xi32>, %v : i32) {
// CHECK: %[[A:.*]]: memref<100xi32>, %[[B:.*]]: memref // CHECK: %[[A:.*]]: memref<100xi32>, %[[B:.*]]: memref
affine.for %i = 0 to 100 { affine.for %i = 0 to 100 {
affine.store %v, %A[%i] : memref<100xi32> affine.store %v, %A[%i] : memref<100xi32>
▲ Show 20 Lines • Show All 247 Lines • Show Last 20 Lines

mlir/test/Dialect/Affine/memref-stride-calculation.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(test-memref-stride-calculation)" -o /dev/null | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(test-memref-stride-calculation))" -o /dev/null | FileCheck %s
func.func @f(%0: index) { func.func @f(%0: index) {
// CHECK-LABEL: Testing: f // CHECK-LABEL: Testing: f
%1 = memref.alloc() : memref<3x4x5xf32> %1 = memref.alloc() : memref<3x4x5xf32>
// CHECK: MemRefType offset: 0 strides: 20, 5, 1 // CHECK: MemRefType offset: 0 strides: 20, 5, 1
%2 = memref.alloc(%0) : memref<3x4x?xf32> %2 = memref.alloc(%0) : memref<3x4x?xf32>
// CHECK: MemRefType offset: 0 strides: ?, ?, 1 // CHECK: MemRefType offset: 0 strides: ?, ?, 1
%3 = memref.alloc(%0) : memref<3x?x5xf32> %3 = memref.alloc(%0) : memref<3x?x5xf32>
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

mlir/test/Dialect/ControlFlow/canonicalize.mlir

// RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline='func.func(canonicalize)' -split-input-file | FileCheck --dump-input-context 20 %s // RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline='builtin.module(func.func(canonicalize))' -split-input-file | FileCheck --dump-input-context 20 %s
/// Test the folding of BranchOp. /// Test the folding of BranchOp.
// CHECK-LABEL: func @br_folding( // CHECK-LABEL: func @br_folding(
func.func @br_folding() -> i32 { func.func @br_folding() -> i32 {
// CHECK-NEXT: %[[CST:.*]] = arith.constant 0 : i32 // CHECK-NEXT: %[[CST:.*]] = arith.constant 0 : i32
// CHECK-NEXT: return %[[CST]] : i32 // CHECK-NEXT: return %[[CST]] : i32
%c0_i32 = arith.constant 0 : i32 %c0_i32 = arith.constant 0 : i32
▲ Show 20 Lines • Show All 458 Lines • Show Last 20 Lines

mlir/test/Dialect/GPU/promotion.mlir

// RUN: mlir-opt -allow-unregistered-dialect -pass-pipeline='gpu.module(gpu.func(test-gpu-memory-promotion))' -split-input-file %s | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect -pass-pipeline='builtin.module(gpu.module(gpu.func(test-gpu-memory-promotion)))' -split-input-file %s | FileCheck %s
gpu.module @foo { gpu.module @foo {
// Verify that the attribution was indeed introduced // Verify that the attribution was indeed introduced
// CHECK-LABEL: @memref3d // CHECK-LABEL: @memref3d
// CHECK-SAME: (%[[arg:.*]]: memref<5x4xf32> // CHECK-SAME: (%[[arg:.*]]: memref<5x4xf32>
// CHECK-SAME: workgroup(%[[promoted:.*]] : memref<5x4xf32, 3>) // CHECK-SAME: workgroup(%[[promoted:.*]] : memref<5x4xf32, 3>)
gpu.func @memref3d(%arg0: memref<5x4xf32> {gpu.test_promote_workgroup}) kernel { gpu.func @memref3d(%arg0: memref<5x4xf32> {gpu.test_promote_workgroup}) kernel {
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

mlir/test/Dialect/LLVMIR/terminator.mlir

// RUN: mlir-opt -pass-pipeline='func.func(canonicalize)' %s | FileCheck %s // RUN: mlir-opt -pass-pipeline='builtin.module(func.func(canonicalize))' %s | FileCheck %s
// verify that terminators survive the canonicalizer // verify that terminators survive the canonicalizer
// CHECK-LABEL: @return // CHECK-LABEL: @return
// CHECK: llvm.return // CHECK: llvm.return
func.func @return() { func.func @return() {
llvm.return llvm.return
} }
Show All 12 Lines

mlir/test/Dialect/Linalg/convert-elementwise-to-linalg.mlir

// RUN: mlir-opt -pass-pipeline="func.func(convert-elementwise-to-linalg)" -split-input-file %s | FileCheck %s // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-elementwise-to-linalg))" -split-input-file %s | FileCheck %s
// In-depth checking of the linalg.generic op for a very trivial case. // In-depth checking of the linalg.generic op for a very trivial case.
// CHECK: #[[$MAP:.*]] = affine_map<() -> ()> // CHECK: #[[$MAP:.*]] = affine_map<() -> ()>
// CHECK-LABEL: func @addf_rank0 // CHECK-LABEL: func @addf_rank0
// CHECK-SAME: %[[ARG0:[0-9a-zA-Z]*]]: tensor<f32> // CHECK-SAME: %[[ARG0:[0-9a-zA-Z]*]]: tensor<f32>
// CHECK-SAME: %[[ARG1:[0-9a-zA-Z]*]]: tensor<f32> // CHECK-SAME: %[[ARG1:[0-9a-zA-Z]*]]: tensor<f32>
func.func @addf_rank0(%arg0: tensor<f32>, %arg1: tensor<f32>) -> tensor<f32> { func.func @addf_rank0(%arg0: tensor<f32>, %arg1: tensor<f32>) -> tensor<f32> {
// CHECK: %{{.*}} = linalg.generic // CHECK: %{{.*}} = linalg.generic
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/detensorize_0d.mlir

// RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline="func.func(linalg-detensorize{aggressive-mode})" | FileCheck %s // RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline="builtin.module(func.func(linalg-detensorize{aggressive-mode}))" | FileCheck %s
#map = affine_map<() -> ()> #map = affine_map<() -> ()>
func.func @detensor_simple(%arg1: tensor<f32>, %arg2: tensor<f32>) -> tensor<f32> attributes {iree.module.export} { func.func @detensor_simple(%arg1: tensor<f32>, %arg2: tensor<f32>) -> tensor<f32> attributes {iree.module.export} {
%0 = tensor.empty() : tensor<f32> %0 = tensor.empty() : tensor<f32>
%1 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = []} %1 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = []}
ins(%arg1, %arg2 : tensor<f32>, tensor<f32>) ins(%arg1, %arg2 : tensor<f32>, tensor<f32>)
outs(%0 : tensor<f32>) { outs(%0 : tensor<f32>) {
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/detensorize_br_operands.mlir

// RUN: mlir-opt %s -split-input-file -allow-unregistered-dialect -pass-pipeline="func.func(linalg-detensorize)" | FileCheck %s // RUN: mlir-opt %s -split-input-file -allow-unregistered-dialect -pass-pipeline="builtin.module(func.func(linalg-detensorize))" | FileCheck %s
// TODO: Detensoring breaks if %arg0 or %arg1 are passed directly as tensors. Fix that. // TODO: Detensoring breaks if %arg0 or %arg1 are passed directly as tensors. Fix that.
func.func @if_true_test(%arg0: i1, %arg1: i32) -> tensor<i32> attributes {} { func.func @if_true_test(%arg0: i1, %arg1: i32) -> tensor<i32> attributes {} {
%arg0_t = tensor.from_elements %arg0 : tensor<i1> %arg0_t = tensor.from_elements %arg0 : tensor<i1>
%arg1_t = tensor.from_elements %arg1 : tensor<i32> %arg1_t = tensor.from_elements %arg1 : tensor<i32>
%cst = arith.constant dense<10> : tensor<i32> %cst = arith.constant dense<10> : tensor<i32>
%2 = tensor.empty() : tensor<i8> %2 = tensor.empty() : tensor<i8>
Show All 36 Lines

mlir/test/Dialect/Linalg/detensorize_if.mlir

// RUN: mlir-opt %s -split-input-file -allow-unregistered-dialect -pass-pipeline="func.func(linalg-detensorize)" | FileCheck %s // RUN: mlir-opt %s -split-input-file -allow-unregistered-dialect -pass-pipeline="builtin.module(func.func(linalg-detensorize))" | FileCheck %s
#map0 = affine_map<() -> ()> #map0 = affine_map<() -> ()>
#attrs = { #attrs = {
indexing_maps = [#map0, #map0, #map0], indexing_maps = [#map0, #map0, #map0],
iterator_types = [] iterator_types = []
} }
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/detensorize_trivial.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(linalg-detensorize{aggressive-mode})" | FileCheck %s -check-prefix=DET-ALL // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(linalg-detensorize{aggressive-mode}))" | FileCheck %s -check-prefix=DET-ALL
// RUN: mlir-opt %s -pass-pipeline="func.func(linalg-detensorize)" | FileCheck %s -check-prefix=DET-CF // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(linalg-detensorize))" | FileCheck %s -check-prefix=DET-CF
#map0 = affine_map<() -> ()> #map0 = affine_map<() -> ()>
#attrs = { #attrs = {
indexing_maps = [#map0, #map0, #map0], indexing_maps = [#map0, #map0, #map0],
iterator_types = [] iterator_types = []
} }
Show All 34 Lines

mlir/test/Dialect/Linalg/detensorize_while.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(linalg-detensorize{aggressive-mode})" | FileCheck %s -check-prefix=DET-ALL // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(linalg-detensorize{aggressive-mode}))" | FileCheck %s -check-prefix=DET-ALL
// RUN: mlir-opt %s -pass-pipeline="func.func(linalg-detensorize)" | FileCheck %s -check-prefix=DET-CF // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(linalg-detensorize))" | FileCheck %s -check-prefix=DET-CF
#map0 = affine_map<() -> ()> #map0 = affine_map<() -> ()>
#attrs = { #attrs = {
indexing_maps = [#map0, #map0, #map0], indexing_maps = [#map0, #map0, #map0],
iterator_types = [] iterator_types = []
} }
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/detensorize_while_impure_cf.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(linalg-detensorize{aggressive-mode})" | FileCheck %s -check-prefix=DET-ALL // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(linalg-detensorize{aggressive-mode}))" | FileCheck %s -check-prefix=DET-ALL
// RUN: mlir-opt %s -pass-pipeline="func.func(linalg-detensorize)" | FileCheck %s -check-prefix=DET-CF // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(linalg-detensorize))" | FileCheck %s -check-prefix=DET-CF
#map0 = affine_map<() -> ()> #map0 = affine_map<() -> ()>
#map1 = affine_map<(i) -> ()> #map1 = affine_map<(i) -> ()>
#map2 = affine_map<(i) -> (i)> #map2 = affine_map<(i) -> (i)>
#attrs = { #attrs = {
indexing_maps = [#map0, #map0, #map0], indexing_maps = [#map0, #map0, #map0],
iterator_types = [] iterator_types = []
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/detensorize_while_pure_cf.mlir

// RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline="func.func(linalg-detensorize)" | FileCheck %s // RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline="builtin.module(func.func(linalg-detensorize))" | FileCheck %s
#map0 = affine_map<() -> ()> #map0 = affine_map<() -> ()>
#attrs = { #attrs = {
indexing_maps = [#map0, #map0, #map0], indexing_maps = [#map0, #map0, #map0],
iterator_types = [] iterator_types = []
} }
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/drop-unit-extent-dims.mlir

// RUN: mlir-opt %s -split-input-file -pass-pipeline="func.func(linalg-fold-unit-extent-dims)" | FileCheck %s // RUN: mlir-opt %s -split-input-file -pass-pipeline="builtin.module(func.func(linalg-fold-unit-extent-dims))" | FileCheck %s
#accesses = [ #accesses = [
affine_map<(i, j, k, l, m) -> (i, k, m)>, affine_map<(i, j, k, l, m) -> (i, k, m)>,
affine_map<(i, j, k, l, m) -> ()>, affine_map<(i, j, k, l, m) -> ()>,
affine_map<(i, j, k, l, m) -> (i, k, j, l, m)> affine_map<(i, j, k, l, m) -> (i, k, j, l, m)>
] ]
#trait = { #trait = {
▲ Show 20 Lines • Show All 863 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/fold-unit-trip-loops.mlir

// RUN: mlir-opt %s -split-input-file -pass-pipeline="func.func(linalg-fold-unit-extent-dims{fold-one-trip-loops-only})" | FileCheck %s // RUN: mlir-opt %s -split-input-file -pass-pipeline="builtin.module(func.func(linalg-fold-unit-extent-dims{fold-one-trip-loops-only}))" | FileCheck %s
#accesses = [ #accesses = [
affine_map<(i, j, k, l, m) -> (i, k, m)>, affine_map<(i, j, k, l, m) -> (i, k, m)>,
affine_map<(i, j, k, l, m) -> (i, k, j, l, m)> affine_map<(i, j, k, l, m) -> (i, k, j, l, m)>
] ]
#trait = { #trait = {
iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"],
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

mlir/test/Dialect/NVGPU/optimize-shared-memory.mlir

// RUN: mlir-opt %s -split-input-file --pass-pipeline='func.func(nvgpu-optimize-shared-memory)' | FileCheck %s // RUN: mlir-opt %s -split-input-file --pass-pipeline='builtin.module(func.func(nvgpu-optimize-shared-memory))' | FileCheck %s
// CHECK: @optimize_128x32xf16_32x128xf16([[arg0:%.+]]: memref<{{.*}}>, [[ldRow:%.+]]: index, [[ldCol:%.+]]: index, [[stRow:%.+]]: index, [[stCol:%.+]]: index, [[fragRow:%.+]]: index, [[fragCol:%.+]]: index) // CHECK: @optimize_128x32xf16_32x128xf16([[arg0:%.+]]: memref<{{.*}}>, [[ldRow:%.+]]: index, [[ldCol:%.+]]: index, [[stRow:%.+]]: index, [[stCol:%.+]]: index, [[fragRow:%.+]]: index, [[fragCol:%.+]]: index)
func.func @optimize_128x32xf16_32x128xf16(%arg0: memref<128x128xf16>, func.func @optimize_128x32xf16_32x128xf16(%arg0: memref<128x128xf16>,
%ldRow: index, %ldCol: index, %ldRow: index, %ldCol: index,
%stRow: index, %stCol: index, %stRow: index, %stCol: index,
%fragRow: index, %fragCol :index) %fragRow: index, %fragCol :index)
-> (vector<4x2xf16>, vector<4x2xf16>) { -> (vector<4x2xf16>, vector<4x2xf16>) {
// CHECK: [[shm:%.+]] = memref.alloc // CHECK: [[shm:%.+]] = memref.alloc
▲ Show 20 Lines • Show All 231 Lines • Show Last 20 Lines

mlir/test/Dialect/Quant/canonicalize.mlir

// RUN: mlir-opt %s -split-input-file -pass-pipeline='func.func(canonicalize)' | FileCheck %s // RUN: mlir-opt %s -split-input-file -pass-pipeline='builtin.module(func.func(canonicalize))' | FileCheck %s
// ----- // -----
// CHECK-LABEL: redundant_scast // CHECK-LABEL: redundant_scast
func.func @redundant_scast() -> tensor<4xi8> { func.func @redundant_scast() -> tensor<4xi8> {
// CHECK-NEXT: arith.constant dense<10> : tensor<4xi8> // CHECK-NEXT: arith.constant dense<10> : tensor<4xi8>
// CHECK-NEXT: return // CHECK-NEXT: return
%cst = arith.constant dense<5> : tensor<4xi8> %cst = arith.constant dense<5> : tensor<4xi8>
%1 = "quant.scast"(%cst) : (tensor<4xi8>) -> tensor<4x!quant.uniform<u8:f32, 7.812500e-03:128>> %1 = "quant.scast"(%cst) : (tensor<4xi8>) -> tensor<4x!quant.uniform<u8:f32, 7.812500e-03:128>>
Show All 15 Lines

mlir/test/Dialect/SCF/canonicalize.mlir

// RUN: mlir-opt %s -pass-pipeline='func.func(canonicalize)' -split-input-file | FileCheck %s // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(canonicalize))' -split-input-file | FileCheck %s
// ----- // -----
func.func @single_iteration_some(%A: memref<?x?x?xi32>) { func.func @single_iteration_some(%A: memref<?x?x?xi32>) {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
▲ Show 20 Lines • Show All 1,471 Lines • Show Last 20 Lines

mlir/test/Dialect/SCF/for-loop-to-while-loop.mlir

// RUN: mlir-opt %s -pass-pipeline='func.func(scf-for-to-while)' -split-input-file | FileCheck %s // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(scf-for-to-while))' -split-input-file | FileCheck %s
// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py // NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
// CHECK-LABEL: func @single_loop( // CHECK-LABEL: func @single_loop(
// CHECK-SAME: %[[VAL_0:.*]]: memref<?xi32>, // CHECK-SAME: %[[VAL_0:.*]]: memref<?xi32>,
// CHECK-SAME: %[[VAL_1:.*]]: index, // CHECK-SAME: %[[VAL_1:.*]]: index,
// CHECK-SAME: %[[VAL_2:.*]]: i32) { // CHECK-SAME: %[[VAL_2:.*]]: i32) {
// CHECK: %[[VAL_3:.*]] = arith.constant 0 : index // CHECK: %[[VAL_3:.*]] = arith.constant 0 : index
// CHECK: %[[VAL_4:.*]] = arith.constant 1 : index // CHECK: %[[VAL_4:.*]] = arith.constant 1 : index
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

mlir/test/Dialect/SCF/loop-range.mlir

// RUN: mlir-opt %s -pass-pipeline='func.func(scf-for-loop-range-folding)' -split-input-file | FileCheck %s // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(scf-for-loop-range-folding))' -split-input-file | FileCheck %s
func.func @fold_one_loop(%arg0: memref<?xi32>, %arg1: index, %arg2: index) { func.func @fold_one_loop(%arg0: memref<?xi32>, %arg1: index, %arg2: index) {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
scf.for %i = %c0 to %arg1 step %c1 { scf.for %i = %c0 to %arg1 step %c1 {
%0 = arith.addi %arg2, %i : index %0 = arith.addi %arg2, %i : index
%1 = arith.muli %0, %c4 : index %1 = arith.muli %0, %c4 : index
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

mlir/test/Dialect/SCF/parallel-loop-fusion.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func.func(scf-parallel-loop-fusion)' -split-input-file | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.module(func.func(scf-parallel-loop-fusion))' -split-input-file | FileCheck %s
func.func @fuse_empty_loops() { func.func @fuse_empty_loops() {
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) { scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) {
scf.yield scf.yield
} }
▲ Show 20 Lines • Show All 350 Lines • Show Last 20 Lines

mlir/test/Dialect/SCF/parallel-loop-tiling-inbound-check.mlir

// RUN: mlir-opt %s -pass-pipeline='func.func(scf-parallel-loop-tiling{parallel-loop-tile-sizes=1,4 no-min-max-bounds=true})' -split-input-file | FileCheck %s // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(scf-parallel-loop-tiling{parallel-loop-tile-sizes=1,4 no-min-max-bounds=true}))' -split-input-file | FileCheck %s
func.func @parallel_loop(%arg0 : index, %arg1 : index, %arg2 : index, func.func @parallel_loop(%arg0 : index, %arg1 : index, %arg2 : index,
%arg3 : index, %arg4 : index, %arg5 : index, %arg3 : index, %arg4 : index, %arg5 : index,
%A: memref<?x?xf32>, %B: memref<?x?xf32>, %A: memref<?x?xf32>, %B: memref<?x?xf32>,
%C: memref<?x?xf32>, %result: memref<?x?xf32>) { %C: memref<?x?xf32>, %result: memref<?x?xf32>) {
scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3) step (%arg4, %arg5) { scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3) step (%arg4, %arg5) {
%B_elem = memref.load %B[%i0, %i1] : memref<?x?xf32> %B_elem = memref.load %B[%i0, %i1] : memref<?x?xf32>
%C_elem = memref.load %C[%i0, %i1] : memref<?x?xf32> %C_elem = memref.load %C[%i0, %i1] : memref<?x?xf32>
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

mlir/test/Dialect/SCF/parallel-loop-tiling.mlir

// RUN: mlir-opt %s -pass-pipeline='func.func(scf-parallel-loop-tiling{parallel-loop-tile-sizes=1,4})' -split-input-file | FileCheck %s // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(scf-parallel-loop-tiling{parallel-loop-tile-sizes=1,4}))' -split-input-file | FileCheck %s
func.func @parallel_loop(%arg0 : index, %arg1 : index, %arg2 : index, func.func @parallel_loop(%arg0 : index, %arg1 : index, %arg2 : index,
%arg3 : index, %arg4 : index, %arg5 : index, %arg3 : index, %arg4 : index, %arg5 : index,
%A: memref<?x?xf32>, %B: memref<?x?xf32>, %A: memref<?x?xf32>, %B: memref<?x?xf32>,
%C: memref<?x?xf32>, %result: memref<?x?xf32>) { %C: memref<?x?xf32>, %result: memref<?x?xf32>) {
scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3) step (%arg4, %arg5) { scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3) step (%arg4, %arg5) {
%B_elem = memref.load %B[%i0, %i1] : memref<?x?xf32> %B_elem = memref.load %B[%i0, %i1] : memref<?x?xf32>
%C_elem = memref.load %C[%i0, %i1] : memref<?x?xf32> %C_elem = memref.load %C[%i0, %i1] : memref<?x?xf32>
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -split-input-file -pass-pipeline='func.func(canonicalize)' | FileCheck %s // RUN: mlir-opt %s -split-input-file -pass-pipeline='builtin.module(func.func(canonicalize))' | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spirv.AccessChain // spirv.AccessChain
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func.func @combine_full_access_chain() -> f32 { func.func @combine_full_access_chain() -> f32 {
// CHECK: %[[INDEX:.*]] = spirv.Constant 0 // CHECK: %[[INDEX:.*]] = spirv.Constant 0
// CHECK-NEXT: %[[VAR:.*]] = spirv.Variable // CHECK-NEXT: %[[VAR:.*]] = spirv.Variable
▲ Show 20 Lines • Show All 756 Lines • Show Last 20 Lines

mlir/test/Dialect/SPIRV/Transforms/inlining.mlir

// RUN: mlir-opt %s -split-input-file -pass-pipeline='spirv.module(inline{default-pipeline=''})' | FileCheck %s // RUN: mlir-opt %s -split-input-file -pass-pipeline='builtin.module(spirv.module(inline{default-pipeline=''}))' | FileCheck %s
spirv.module Logical GLSL450 { spirv.module Logical GLSL450 {
spirv.func @callee() "None" { spirv.func @callee() "None" {
spirv.Return spirv.Return
} }
// CHECK-LABEL: @calling_single_block_ret_func // CHECK-LABEL: @calling_single_block_ret_func
spirv.func @calling_single_block_ret_func() "None" { spirv.func @calling_single_block_ret_func() "None" {
▲ Show 20 Lines • Show All 219 Lines • Show Last 20 Lines

mlir/test/Dialect/Vector/canonicalize.mlir

// RUN: mlir-opt %s -pass-pipeline='func.func(canonicalize)' -split-input-file -allow-unregistered-dialect | FileCheck %s // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(canonicalize))' -split-input-file -allow-unregistered-dialect | FileCheck %s
// ----- // -----
// CHECK-LABEL: create_vector_mask_to_constant_mask // CHECK-LABEL: create_vector_mask_to_constant_mask
func.func @create_vector_mask_to_constant_mask() -> (vector<4x3xi1>) { func.func @create_vector_mask_to_constant_mask() -> (vector<4x3xi1>) {
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%c3 = arith.constant 3 : index %c3 = arith.constant 3 : index
// CHECK: vector.constant_mask [3, 2] : vector<4x3xi1> // CHECK: vector.constant_mask [3, 2] : vector<4x3xi1>
▲ Show 20 Lines • Show All 1,853 Lines • Show Last 20 Lines

mlir/test/IR/diagnostic-handler-filter.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(test-diagnostic-filter{filters=mysource1})" -split-input-file -o - 2>&1 | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(test-diagnostic-filter{filters=mysource1}))" -split-input-file -o - 2>&1 | FileCheck %s
// This test verifies that diagnostic handler can emit the call stack successfully. // This test verifies that diagnostic handler can emit the call stack successfully.
// CHECK-LABEL: Test 'test1' // CHECK-LABEL: Test 'test1'
// CHECK-NEXT: mysource2:1:0: error: test diagnostic // CHECK-NEXT: mysource2:1:0: error: test diagnostic
// CHECK-NEXT: mysource3:2:0: note: called from // CHECK-NEXT: mysource3:2:0: note: called from
func.func private @test1() attributes { func.func private @test1() attributes {
test.loc = loc(callsite("foo"("mysource1":0:0) at callsite("mysource2":1:0 at "mysource3":2:0))) test.loc = loc(callsite("foo"("mysource1":0:0) at callsite("mysource2":1:0 at "mysource3":2:0)))
} }
// ----- // -----
// CHECK-LABEL: Test 'test2' // CHECK-LABEL: Test 'test2'
// CHECK-NEXT: mysource1:0:0: error: test diagnostic // CHECK-NEXT: mysource1:0:0: error: test diagnostic
func.func private @test2() attributes { func.func private @test2() attributes {
test.loc = loc("mysource1":0:0) test.loc = loc("mysource1":0:0)
} }

mlir/test/IR/test-clone.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="func.func(test-clone)" -split-input-file // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="builtin.module(func.func(test-clone))" -split-input-file
module { module {
func.func @fixpoint(%arg1 : i32) -> i32 { func.func @fixpoint(%arg1 : i32) -> i32 {
%r = "test.use"(%arg1) ({ %r = "test.use"(%arg1) ({
"test.yield"(%arg1) : (i32) -> () "test.yield"(%arg1) : (i32) -> ()
}) : (i32) -> i32 }) : (i32) -> i32
return %r : i32 return %r : i32
} }
Show All 11 Lines

mlir/test/IR/test-matchers.mlir

// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline="func.func(test-matchers)" -o /dev/null 2>&1 | FileCheck %s // RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline="builtin.module(func.func(test-matchers))" -o /dev/null 2>&1 | FileCheck %s
func.func @test1(%a: f32, %b: f32, %c: f32) { func.func @test1(%a: f32, %b: f32, %c: f32) {
%0 = arith.addf %a, %b: f32 %0 = arith.addf %a, %b: f32
%1 = arith.addf %a, %c: f32 %1 = arith.addf %a, %c: f32
%2 = arith.addf %c, %b: f32 %2 = arith.addf %c, %b: f32
%3 = arith.mulf %a, %2: f32 %3 = arith.mulf %a, %2: f32
%4 = arith.mulf %3, %1: f32 %4 = arith.mulf %3, %1: f32
%5 = arith.mulf %4, %4: f32 %5 = arith.mulf %4, %4: f32
Show All 34 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-one-shot-bufferize.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(canonicalize,cse),one-shot-bufferize{bufferize-function-boundaries}" |\ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(canonicalize,cse),one-shot-bufferize{bufferize-function-boundaries})" |\
// RUN: mlir-opt -pass-pipeline="func.func(buffer-deallocation,convert-vector-to-scf,lower-affine,convert-linalg-to-loops)" |\ // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(buffer-deallocation,convert-vector-to-scf,lower-affine,convert-linalg-to-loops))" |\
// RUN: mlir-opt -pass-pipeline="func.func(canonicalize,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(canonicalize,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext |\ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext |\
// RUN: FileCheck %s // RUN: FileCheck %s
#map0 = affine_map<(d0, d1)[s0] -> ((d1 - d0) ceildiv s0)> #map0 = affine_map<(d0, d1)[s0] -> ((d1 - d0) ceildiv s0)>
#map1 = affine_map<(d0, d1)[s0] -> ((d0 - d1) ceildiv s0)> #map1 = affine_map<(d0, d1)[s0] -> ((d0 - d1) ceildiv s0)>
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Standard/CPU/test-ceil-floor-pos-neg.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf,memref-expand,arith-expand),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf,memref-expand,arith-expand),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @transfer_read_2d(%A : memref<40xi32>, %base1: index) { func.func @transfer_read_2d(%A : memref<40xi32>, %base1: index) {
%i42 = arith.constant -42: i32 %i42 = arith.constant -42: i32
%f = vector.transfer_read %A[%base1], %i42 %f = vector.transfer_read %A[%base1], %i42
{permutation_map = affine_map<(d0) -> (d0)>} : {permutation_map = affine_map<(d0) -> (d0)>} :
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-transfer-read-1d.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Test for special cases of 1D vector transfer ops. // Test for special cases of 1D vector transfer ops.
memref.global "private" @gv : memref<5x6xf32> = memref.global "private" @gv : memref<5x6xf32> =
dense<[[0. , 1. , 2. , 3. , 4. , 5. ], dense<[[0. , 1. , 2. , 3. , 4. , 5. ],
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-transfer-read-2d.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
memref.global "private" @gv : memref<3x4xf32> = dense<[[0. , 1. , 2. , 3. ], memref.global "private" @gv : memref<3x4xf32> = dense<[[0. , 1. , 2. , 3. ],
[10., 11., 12., 13.], [10., 11., 12., 13.],
[20., 21., 22., 23.]]> [20., 21., 22., 23.]]>
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-transfer-read-3d.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @transfer_read_3d(%A : memref<?x?x?x?xf32>, func.func @transfer_read_3d(%A : memref<?x?x?x?xf32>,
%o: index, %a: index, %b: index, %c: index) { %o: index, %a: index, %b: index, %c: index) {
%fm42 = arith.constant -42.0: f32 %fm42 = arith.constant -42.0: f32
%f = vector.transfer_read %A[%o, %a, %b, %c], %fm42 %f = vector.transfer_read %A[%o, %a, %b, %c], %fm42
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-transfer-read.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @transfer_read_1d(%A : memref<?xf32>, %base: index) { func.func @transfer_read_1d(%A : memref<?xf32>, %base: index) {
%fm42 = arith.constant -42.0: f32 %fm42 = arith.constant -42.0: f32
%f = vector.transfer_read %A[%base], %fm42 %f = vector.transfer_read %A[%base], %fm42
{permutation_map = affine_map<(d0) -> (d0)>} : {permutation_map = affine_map<(d0) -> (d0)>} :
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-transfer-to-loops.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
#map0 = affine_map<(d0, d1) -> (d1, d0)> #map0 = affine_map<(d0, d1) -> (d1, d0)>
#map1 = affine_map<(d0, d1) -> (d1)> #map1 = affine_map<(d0, d1) -> (d1)>
func.func private @printMemrefF32(memref<*xf32>) func.func private @printMemrefF32(memref<*xf32>)
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/GPU/CUDA/test-reduction-distribute.mlir

// RUN: mlir-opt %s -test-vector-warp-distribute="hoist-uniform distribute-transfer-write propagate-distribution" -canonicalize |\ // RUN: mlir-opt %s -test-vector-warp-distribute="hoist-uniform distribute-transfer-write propagate-distribution" -canonicalize |\
// RUN: mlir-opt -test-vector-warp-distribute=rewrite-warp-ops-to-scf-if |\ // RUN: mlir-opt -test-vector-warp-distribute=rewrite-warp-ops-to-scf-if |\
// RUN: mlir-opt -lower-affine -convert-scf-to-cf -convert-vector-to-llvm \ // RUN: mlir-opt -lower-affine -convert-scf-to-cf -convert-vector-to-llvm \
// RUN: -convert-arith-to-llvm -gpu-kernel-outlining |\ // RUN: -convert-arith-to-llvm -gpu-kernel-outlining |\
// RUN: mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,reconcile-unrealized-casts,gpu-to-cubin)' |\ // RUN: mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,reconcile-unrealized-casts,gpu-to-cubin))' |\
// RUN: mlir-opt -gpu-to-llvm -reconcile-unrealized-casts |\ // RUN: mlir-opt -gpu-to-llvm -reconcile-unrealized-casts |\
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Run a tiled reduction fused with an elementwise op. // Run a tiled reduction fused with an elementwise op.
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/GPU/CUDA/test-warp-distribute.mlir

// Run the test cases without distributing ops to test default lowering. Run // Run the test cases without distributing ops to test default lowering. Run
// everything on the same thread. // everything on the same thread.
// RUN: mlir-opt %s -test-vector-warp-distribute=rewrite-warp-ops-to-scf-if -canonicalize | \ // RUN: mlir-opt %s -test-vector-warp-distribute=rewrite-warp-ops-to-scf-if -canonicalize | \
// RUN: mlir-opt -convert-scf-to-cf -convert-cf-to-llvm -convert-vector-to-llvm -convert-arith-to-llvm \ // RUN: mlir-opt -convert-scf-to-cf -convert-cf-to-llvm -convert-vector-to-llvm -convert-arith-to-llvm \
// RUN: -gpu-kernel-outlining |\ // RUN: -gpu-kernel-outlining |\
// RUN: mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,reconcile-unrealized-casts,gpu-to-cubin)' |\ // RUN: mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,reconcile-unrealized-casts,gpu-to-cubin))' |\
// RUN: mlir-opt -gpu-to-llvm -reconcile-unrealized-casts |\ // RUN: mlir-opt -gpu-to-llvm -reconcile-unrealized-casts |\
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Run the same test cases with distribution and propagation. // Run the same test cases with distribution and propagation.
// RUN: mlir-opt %s -test-vector-warp-distribute="hoist-uniform distribute-transfer-write" \ // RUN: mlir-opt %s -test-vector-warp-distribute="hoist-uniform distribute-transfer-write" \
// RUN: -test-vector-warp-distribute=rewrite-warp-ops-to-scf-if -canonicalize | \ // RUN: -test-vector-warp-distribute=rewrite-warp-ops-to-scf-if -canonicalize | \
// RUN: mlir-opt -convert-scf-to-cf -convert-cf-to-llvm -convert-vector-to-llvm -convert-arith-to-llvm \ // RUN: mlir-opt -convert-scf-to-cf -convert-cf-to-llvm -convert-vector-to-llvm -convert-arith-to-llvm \
// RUN: -gpu-kernel-outlining |\ // RUN: -gpu-kernel-outlining |\
// RUN: mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,reconcile-unrealized-casts,gpu-to-cubin)' |\ // RUN: mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,reconcile-unrealized-casts,gpu-to-cubin))' |\
// RUN: mlir-opt -gpu-to-llvm -reconcile-unrealized-casts |\ // RUN: mlir-opt -gpu-to-llvm -reconcile-unrealized-casts |\
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -test-vector-warp-distribute="hoist-uniform distribute-transfer-write propagate-distribution" \ // RUN: mlir-opt %s -test-vector-warp-distribute="hoist-uniform distribute-transfer-write propagate-distribution" \
// RUN: -test-vector-warp-distribute=rewrite-warp-ops-to-scf-if -canonicalize | \ // RUN: -test-vector-warp-distribute=rewrite-warp-ops-to-scf-if -canonicalize | \
// RUN: mlir-opt -convert-scf-to-cf -convert-cf-to-llvm -convert-vector-to-llvm -convert-arith-to-llvm \ // RUN: mlir-opt -convert-scf-to-cf -convert-cf-to-llvm -convert-vector-to-llvm -convert-arith-to-llvm \
// RUN: -gpu-kernel-outlining |\ // RUN: -gpu-kernel-outlining |\
// RUN: mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,reconcile-unrealized-casts,gpu-to-cubin)' |\ // RUN: mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,reconcile-unrealized-casts,gpu-to-cubin))' |\
// RUN: mlir-opt -gpu-to-llvm -reconcile-unrealized-casts |\ // RUN: mlir-opt -gpu-to-llvm -reconcile-unrealized-casts |\
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @gpu_func(%arg1: memref<32xf32>, %arg2: memref<32xf32>) { func.func @gpu_func(%arg1: memref<32xf32>, %arg2: memref<32xf32>) {
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

mlir/test/Integration/GPU/CUDA/TensorCore/wmma-matmul-f16.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin{chip=sm_70})' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin{chip=sm_70}))' \
// RUN: | mlir-opt --convert-scf-to-cf -gpu-to-llvm \ // RUN: | mlir-opt --convert-scf-to-cf -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// Test case to check the working of Tensor cores on Nvidia GPUs. The kernel has already // Test case to check the working of Tensor cores on Nvidia GPUs. The kernel has already
// been outlined to prevent crashing due to introduction of an empty basic block by --gpu- // been outlined to prevent crashing due to introduction of an empty basic block by --gpu-
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

mlir/test/Integration/GPU/CUDA/TensorCore/wmma-matmul-f32.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin{chip=sm_70})' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin{chip=sm_70}))' \
// RUN: | mlir-opt --convert-scf-to-cf -gpu-to-llvm \ // RUN: | mlir-opt --convert-scf-to-cf -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @main() { func.func @main() {
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

mlir/test/Integration/GPU/CUDA/all-reduce-and.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin)' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin))' \
// RUN: | mlir-opt -gpu-to-llvm \ // RUN: | mlir-opt -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @main() { func.func @main() {
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

mlir/test/Integration/GPU/CUDA/all-reduce-max.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin)' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin))' \
// RUN: | mlir-opt -gpu-to-llvm \ // RUN: | mlir-opt -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @main() { func.func @main() {
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

mlir/test/Integration/GPU/CUDA/all-reduce-min.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin)' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin))' \
// RUN: | mlir-opt -gpu-to-llvm \ // RUN: | mlir-opt -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @main() { func.func @main() {
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

mlir/test/Integration/GPU/CUDA/all-reduce-op.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin)' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin))' \
// RUN: | mlir-opt -gpu-to-llvm \ // RUN: | mlir-opt -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// CHECK-COUNT-8: [{{(5356, ){12}5356}}] // CHECK-COUNT-8: [{{(5356, ){12}5356}}]
Show All 28 Lines

mlir/test/Integration/GPU/CUDA/all-reduce-or.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin)' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin))' \
// RUN: | mlir-opt -gpu-to-llvm \ // RUN: | mlir-opt -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @main() { func.func @main() {
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

mlir/test/Integration/GPU/CUDA/all-reduce-region.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin)' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin))' \
// RUN: | mlir-opt -gpu-to-llvm \ // RUN: | mlir-opt -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// CHECK: [{{(35, ){34}35}}] // CHECK: [{{(35, ){34}35}}]
Show All 25 Lines

mlir/test/Integration/GPU/CUDA/all-reduce-xor.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin)' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin))' \
// RUN: | mlir-opt -gpu-to-llvm \ // RUN: | mlir-opt -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @main() { func.func @main() {
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

mlir/test/Integration/GPU/CUDA/async.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin)' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin))' \
// RUN: | mlir-opt -gpu-async-region -gpu-to-llvm \ // RUN: | mlir-opt -gpu-async-region -gpu-to-llvm \
// RUN: | mlir-opt -async-to-async-runtime -async-runtime-ref-counting \ // RUN: | mlir-opt -async-to-async-runtime -async-runtime-ref-counting \
// RUN: | mlir-opt -convert-async-to-llvm -convert-func-to-llvm \ // RUN: | mlir-opt -convert-async-to-llvm -convert-func-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void -O0 \ // RUN: --entry-point-result=void -O0 \
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

mlir/test/Integration/GPU/CUDA/gpu-to-cubin.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin)' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin))' \
// RUN: | mlir-opt -gpu-to-llvm \ // RUN: | mlir-opt -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
Show All 32 Lines

mlir/test/Integration/GPU/CUDA/multiple-all-reduce.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin)' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin))' \
// RUN: | mlir-opt -gpu-to-llvm \ // RUN: | mlir-opt -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @main() { func.func @main() {
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

mlir/test/Integration/GPU/CUDA/shuffle.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin)' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin))' \
// RUN: | mlir-opt -gpu-to-llvm \ // RUN: | mlir-opt -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// CHECK: [4, 5, 6, 7, 0, 1, 2, 3, 12, -1, -1, -1, 8] // CHECK: [4, 5, 6, 7, 0, 1, 2, 3, 12, -1, -1, -1, 8]
Show All 28 Lines

mlir/test/Integration/GPU/CUDA/two-modules.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin)' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin))' \
// RUN: | mlir-opt -gpu-to-llvm \ // RUN: | mlir-opt -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// CHECK: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] // CHECK: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
Show All 25 Lines

mlir/test/Integration/GPU/ROCM/gpu-to-hsaco.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-rocdl,gpu-to-hsaco{chip=%chip})' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-rocdl,gpu-to-hsaco{chip=%chip}))' \
// RUN: | mlir-opt -gpu-to-llvm \ // RUN: | mlir-opt -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_rocm_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_rocm_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @other_func(%arg0 : f32, %arg1 : memref<?xf32>) { func.func @other_func(%arg0 : f32, %arg1 : memref<?xf32>) {
Show All 29 Lines

mlir/test/Integration/GPU/ROCM/printf.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-rocdl{index-bitwidth=32 runtime=HIP},gpu-to-hsaco{chip=%chip})' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-rocdl{index-bitwidth=32 runtime=HIP},gpu-to-hsaco{chip=%chip}))' \
// RUN: | mlir-opt -gpu-to-llvm \ // RUN: | mlir-opt -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_rocm_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_rocm_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// CHECK: Hello from 0 // CHECK: Hello from 0
Show All 19 Lines

mlir/test/Integration/GPU/ROCM/two-modules.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-rocdl,gpu-to-hsaco{chip=%chip})' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-rocdl,gpu-to-hsaco{chip=%chip}))' \
// RUN: | mlir-opt -gpu-to-llvm \ // RUN: | mlir-opt -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_rocm_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_rocm_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// CHECK: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] // CHECK: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
Show All 27 Lines

mlir/test/Integration/GPU/ROCM/vecadd.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -convert-scf-to-cf \ // RUN: | mlir-opt -convert-scf-to-cf \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-rocdl{use-bare-ptr-memref-call-conv=true},gpu-to-hsaco{chip=%chip})' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-rocdl{use-bare-ptr-memref-call-conv=true},gpu-to-hsaco{chip=%chip}))' \
// RUN: | mlir-opt -gpu-to-llvm=use-bare-pointers-for-kernels=true \ // RUN: | mlir-opt -gpu-to-llvm=use-bare-pointers-for-kernels=true \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_rocm_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_rocm_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @vecadd(%arg0 : memref<5xf32>, %arg1 : memref<5xf32>, %arg2 : memref<5xf32>) { func.func @vecadd(%arg0 : memref<5xf32>, %arg1 : memref<5xf32>, %arg2 : memref<5xf32>) {
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

mlir/test/Integration/GPU/ROCM/vector-transferops.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: | mlir-opt -convert-scf-to-cf \ // RUN: | mlir-opt -convert-scf-to-cf \
// RUN: | mlir-opt -gpu-kernel-outlining \ // RUN: | mlir-opt -gpu-kernel-outlining \
// RUN: | mlir-opt -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-rocdl{chipset=%chip index-bitwidth=32},gpu-to-hsaco{chip=%chip})' \ // RUN: | mlir-opt -pass-pipeline='builtin.module(gpu.module(strip-debuginfo,convert-gpu-to-rocdl{chipset=%chip index-bitwidth=32},gpu-to-hsaco{chip=%chip}))' \
// RUN: | mlir-opt -gpu-to-llvm \ // RUN: | mlir-opt -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_rocm_runtime%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_rocm_runtime%shlibext \
// RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// TODO: swap for vector transfer reads if we ever create a --vector-to-amdgpu // TODO: swap for vector transfer reads if we ever create a --vector-to-amdgpu
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

mlir/test/Pass/crash-recovery-dynamic-failure.mlir

// Check that local reproducers will also traverse dynamic pass pipelines. // Check that local reproducers will also traverse dynamic pass pipelines.
// RUN: mlir-opt %s -pass-pipeline='test-module-pass,test-dynamic-pipeline{op-name=inner_mod1 run-on-nested-operations=1 dynamic-pipeline=test-pass-failure}' -mlir-pass-pipeline-crash-reproducer=%t -verify-diagnostics -mlir-pass-pipeline-local-reproducer --mlir-disable-threading // RUN: mlir-opt %s -pass-pipeline='builtin.module(test-module-pass,test-dynamic-pipeline{op-name=inner_mod1 run-on-nested-operations=1 dynamic-pipeline=test-pass-failure})' -mlir-pass-pipeline-crash-reproducer=%t -verify-diagnostics -mlir-pass-pipeline-local-reproducer --mlir-disable-threading
// RUN: cat %t | FileCheck -check-prefix=REPRO_LOCAL_DYNAMIC_FAILURE %s // RUN: cat %t | FileCheck -check-prefix=REPRO_LOCAL_DYNAMIC_FAILURE %s
// The crash recovery mechanism will leak memory allocated in the crashing thread. // The crash recovery mechanism will leak memory allocated in the crashing thread.
// UNSUPPORTED: asan // UNSUPPORTED: asan
module @inner_mod1 { module @inner_mod1 {
// expected-error@below {{Failures have been detected while processing an MLIR pass pipeline}} // expected-error@below {{Failures have been detected while processing an MLIR pass pipeline}}
// expected-note@below {{Pipeline failed while executing}} // expected-note@below {{Pipeline failed while executing}}
module @foo {} module @foo {}
} }
// REPRO_LOCAL_DYNAMIC_FAILURE: module @inner_mod1 // REPRO_LOCAL_DYNAMIC_FAILURE: module @inner_mod1
// REPRO_LOCAL_DYNAMIC_FAILURE: module @foo { // REPRO_LOCAL_DYNAMIC_FAILURE: module @foo {
// REPRO_LOCAL_DYNAMIC_FAILURE: pipeline: "builtin.module(test-pass-failure)" // REPRO_LOCAL_DYNAMIC_FAILURE: pipeline: "builtin.module(test-pass-failure)"

mlir/test/Pass/crash-recovery.mlir

// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-module-pass, test-pass-crash)' -mlir-pass-pipeline-crash-reproducer=%t -verify-diagnostics // RUN: mlir-opt %s -pass-pipeline='builtin.module(builtin.module(test-module-pass, test-pass-crash))' -mlir-pass-pipeline-crash-reproducer=%t -verify-diagnostics
// RUN: cat %t | FileCheck -check-prefix=REPRO %s // RUN: cat %t | FileCheck -check-prefix=REPRO %s
// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-module-pass, test-pass-crash)' -mlir-pass-pipeline-crash-reproducer=%t -verify-diagnostics -mlir-pass-pipeline-local-reproducer -mlir-disable-threading // RUN: mlir-opt %s -pass-pipeline='builtin.module(builtin.module(test-module-pass, test-pass-crash))' -mlir-pass-pipeline-crash-reproducer=%t -verify-diagnostics -mlir-pass-pipeline-local-reproducer -mlir-disable-threading
// RUN: cat %t | FileCheck -check-prefix=REPRO_LOCAL %s // RUN: cat %t | FileCheck -check-prefix=REPRO_LOCAL %s
// Check that we correctly handle verifiers passes with local reproducer, this used to crash. // Check that we correctly handle verifiers passes with local reproducer, this used to crash.
// RUN: mlir-opt %s -test-module-pass -test-module-pass -test-module-pass -mlir-pass-pipeline-crash-reproducer=%t -mlir-pass-pipeline-local-reproducer -mlir-disable-threading // RUN: mlir-opt %s -test-module-pass -test-module-pass -test-module-pass -mlir-pass-pipeline-crash-reproducer=%t -mlir-pass-pipeline-local-reproducer -mlir-disable-threading
// RUN: cat %t | FileCheck -check-prefix=REPRO_LOCAL %s // RUN: cat %t | FileCheck -check-prefix=REPRO_LOCAL %s
// Check that local reproducers will also traverse dynamic pass pipelines. // Check that local reproducers will also traverse dynamic pass pipelines.
// RUN: mlir-opt %s -pass-pipeline='test-module-pass,test-dynamic-pipeline{op-name=inner_mod1 run-on-nested-operations=1 dynamic-pipeline=test-pass-crash}' -mlir-pass-pipeline-crash-reproducer=%t -verify-diagnostics -mlir-pass-pipeline-local-reproducer --mlir-disable-threading // RUN: mlir-opt %s -pass-pipeline='builtin.module(test-module-pass,test-dynamic-pipeline{op-name=inner_mod1 run-on-nested-operations=1 dynamic-pipeline=test-pass-crash})' -mlir-pass-pipeline-crash-reproducer=%t -verify-diagnostics -mlir-pass-pipeline-local-reproducer --mlir-disable-threading
// RUN: cat %t | FileCheck -check-prefix=REPRO_LOCAL_DYNAMIC %s // RUN: cat %t | FileCheck -check-prefix=REPRO_LOCAL_DYNAMIC %s
// The crash recovery mechanism will leak memory allocated in the crashing thread. // The crash recovery mechanism will leak memory allocated in the crashing thread.
// UNSUPPORTED: asan // UNSUPPORTED: asan
// expected-error@below {{Failures have been detected while processing an MLIR pass pipeline}} // expected-error@below {{Failures have been detected while processing an MLIR pass pipeline}}
// expected-note@below {{Pipeline failed while executing}} // expected-note@below {{Pipeline failed while executing}}
module @inner_mod1 { module @inner_mod1 {
Show All 14 Lines

mlir/test/Pass/dynamic-pipeline-fail-on-parent.mlir

// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1 run-on-parent=1 dynamic-pipeline=test-patterns})' -split-input-file -verify-diagnostics // RUN: mlir-opt %s -pass-pipeline='builtin.module(builtin.module(test-dynamic-pipeline{op-name=inner_mod1 run-on-parent=1 dynamic-pipeline=test-patterns}))' -split-input-file -verify-diagnostics
// Verify that we fail to schedule a dynamic pipeline on the parent operation. // Verify that we fail to schedule a dynamic pipeline on the parent operation.
// expected-error @+1 {{'builtin.module' op Trying to schedule a dynamic pipeline on an operation that isn't nested under the current operation}} // expected-error @+1 {{'builtin.module' op Trying to schedule a dynamic pipeline on an operation that isn't nested under the current operation}}
module { module {
module @inner_mod1 { module @inner_mod1 {
"test.symbol"() {sym_name = "foo"} : () -> () "test.symbol"() {sym_name = "foo"} : () -> ()
func.func private @bar() func.func private @bar()
} }
} }

mlir/test/Pass/dynamic-pipeline-nested.mlir

// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1 dynamic-pipeline=cse})' --mlir-disable-threading -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=NOTNESTED --check-prefix=CHECK // RUN: mlir-opt %s -pass-pipeline='builtin.module(builtin.module(test-dynamic-pipeline{op-name=inner_mod1 dynamic-pipeline=cse}))' --mlir-disable-threading -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=NOTNESTED --check-prefix=CHECK
// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1 run-on-nested-operations=1 dynamic-pipeline=cse})' --mlir-disable-threading -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=NESTED --check-prefix=CHECK // RUN: mlir-opt %s -pass-pipeline='builtin.module(builtin.module(test-dynamic-pipeline{op-name=inner_mod1 run-on-nested-operations=1 dynamic-pipeline=cse}))' --mlir-disable-threading -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=NESTED --check-prefix=CHECK
// Verify that we can schedule a dynamic pipeline on a nested operation // Verify that we can schedule a dynamic pipeline on a nested operation
func.func @f() { func.func @f() {
return return
} }
Show All 18 Lines

mlir/test/Pass/dynamic-pipeline.mlir

// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1, dynamic-pipeline=func.func(cse,canonicalize)})' --mlir-disable-threading -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD1-ONLY --check-prefix=CHECK // RUN: mlir-opt %s -pass-pipeline='builtin.module(builtin.module(test-dynamic-pipeline{op-name=inner_mod1, dynamic-pipeline=func.func(cse,canonicalize)}))' --mlir-disable-threading -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD1-ONLY --check-prefix=CHECK
// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod2, dynamic-pipeline=func.func(cse,canonicalize)})' --mlir-disable-threading -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD2 --check-prefix=MOD2-ONLY --check-prefix=CHECK // RUN: mlir-opt %s -pass-pipeline='builtin.module(builtin.module(test-dynamic-pipeline{op-name=inner_mod2, dynamic-pipeline=func.func(cse,canonicalize)}))' --mlir-disable-threading -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD2 --check-prefix=MOD2-ONLY --check-prefix=CHECK
// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1,inner_mod2, dynamic-pipeline=func.func(cse,canonicalize)})' --mlir-disable-threading -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD2 --check-prefix=CHECK // RUN: mlir-opt %s -pass-pipeline='builtin.module(builtin.module(test-dynamic-pipeline{op-name=inner_mod1,inner_mod2, dynamic-pipeline=func.func(cse,canonicalize)}))' --mlir-disable-threading -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD2 --check-prefix=CHECK
// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{dynamic-pipeline=func.func(cse,canonicalize)})' --mlir-disable-threading -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD2 --check-prefix=CHECK // RUN: mlir-opt %s -pass-pipeline='builtin.module(builtin.module(test-dynamic-pipeline{dynamic-pipeline=func.func(cse,canonicalize)}))' --mlir-disable-threading -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD2 --check-prefix=CHECK
func.func @f() { func.func @f() {
return return
} }
// CHECK: IR Dump Before // CHECK: IR Dump Before
// CHECK-SAME: TestDynamicPipelinePass // CHECK-SAME: TestDynamicPipelinePass
Show All 32 Lines

mlir/test/Pass/generic-pipeline.mlir

// RUN: mlir-opt %s -verify-diagnostics -pass-pipeline='any(cse, test-interface-pass)' -allow-unregistered-dialect -o /dev/null // RUN: mlir-opt %s -verify-diagnostics -pass-pipeline='builtin.module(any(cse, test-interface-pass))' -allow-unregistered-dialect -o /dev/null
// Test that we execute generic pipelines correctly. The `cse` pass is fully generic and should execute // Test that we execute generic pipelines correctly. The `cse` pass is fully generic and should execute
// on both the module and the func. The `test-interface-pass` filters based on FunctionOpInterface and // on both the module and the func. The `test-interface-pass` filters based on FunctionOpInterface and
// should only execute on the func. // should only execute on the func.
// expected-remark@below {{Executing interface pass on operation}} // expected-remark@below {{Executing interface pass on operation}}
func.func @main() -> (i1, i1) { func.func @main() -> (i1, i1) {
// CHECK-LABEL: func @main // CHECK-LABEL: func @main
Show All 15 Lines

mlir/test/Pass/interface-pass.mlir

// RUN: mlir-opt %s -verify-diagnostics -pass-pipeline='func.func(test-interface-pass)' -o /dev/null // RUN: mlir-opt %s -verify-diagnostics -pass-pipeline='builtin.module(func.func(test-interface-pass))' -o /dev/null
// Test that we run the interface pass on the function. // Test that we run the interface pass on the function.
// expected-remark@below {{Executing interface pass on operation}} // expected-remark@below {{Executing interface pass on operation}}
func.func @main() { func.func @main() {
return return
} }

mlir/test/Pass/invalid-interface-pass.mlir

// RUN: not mlir-opt %s -pass-pipeline='test-interface-pass' 2>&1 | FileCheck %s // RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-interface-pass)' 2>&1 | FileCheck %s
// Test that we emit an error when an interface pass is added to a pass manager it can't be scheduled on. // Test that we emit an error when an interface pass is added to a pass manager it can't be scheduled on.
// CHECK: unable to schedule pass '{{.*}}' on a PassManager intended to run on 'builtin.module'! // CHECK: unable to schedule pass '{{.*}}' on a PassManager intended to run on 'builtin.module'!
func.func @main() { func.func @main() {
return return
} }

mlir/test/Pass/invalid-ir-print-after-failure.mlir

// RUN: not mlir-opt %s -pass-pipeline='func.func(test-pass-create-invalid-ir{emit-invalid-ir=true signal-pass-failure=true})' -mlir-print-ir-after-failure 2>&1 | FileCheck %s --check-prefix=CHECK-GENERIC // RUN: not mlir-opt %s -pass-pipeline='builtin.module(func.func(test-pass-create-invalid-ir{emit-invalid-ir=true signal-pass-failure=true}))' -mlir-print-ir-after-failure 2>&1 | FileCheck %s --check-prefix=CHECK-GENERIC
// RUN: not mlir-opt %s -pass-pipeline='func.func(test-pass-create-invalid-ir{emit-invalid-ir=true signal-pass-failure=false})' -mlir-print-ir-after-failure 2>&1 | FileCheck %s --check-prefix=CHECK-GENERIC // RUN: not mlir-opt %s -pass-pipeline='builtin.module(func.func(test-pass-create-invalid-ir{emit-invalid-ir=true signal-pass-failure=false}))' -mlir-print-ir-after-failure 2>&1 | FileCheck %s --check-prefix=CHECK-GENERIC
// RUN: not mlir-opt %s -pass-pipeline='func.func(test-pass-create-invalid-ir{emit-invalid-ir=false signal-pass-failure=true})' -mlir-print-ir-after-failure 2>&1 | FileCheck %s --check-prefix=CHECK-CUSTOM // RUN: not mlir-opt %s -pass-pipeline='builtin.module(func.func(test-pass-create-invalid-ir{emit-invalid-ir=false signal-pass-failure=true}))' -mlir-print-ir-after-failure 2>&1 | FileCheck %s --check-prefix=CHECK-CUSTOM
// RUN: mlir-opt %s -pass-pipeline='func.func(test-pass-create-invalid-ir{emit-invalid-ir=false signal-pass-failure=false})' -mlir-print-ir-after-failure 2>&1 | FileCheck %s --check-prefix=CHECK-CUSTOM // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(test-pass-create-invalid-ir{emit-invalid-ir=false signal-pass-failure=false}))' -mlir-print-ir-after-failure 2>&1 | FileCheck %s --check-prefix=CHECK-CUSTOM
// Check that `-mlir-print-assume-verified` will print custom even when the IR is invalid. // Check that `-mlir-print-assume-verified` will print custom even when the IR is invalid.
// RUN: not mlir-opt %s -pass-pipeline='func.func(test-pass-create-invalid-ir{emit-invalid-ir=true signal-pass-failure=true})' -mlir-print-ir-after-failure 2>&1 -mlir-print-assume-verified | FileCheck %s --check-prefix=CHECK-CUSTOM // RUN: not mlir-opt %s -pass-pipeline='builtin.module(func.func(test-pass-create-invalid-ir{emit-invalid-ir=true signal-pass-failure=true}))' -mlir-print-ir-after-failure 2>&1 -mlir-print-assume-verified | FileCheck %s --check-prefix=CHECK-CUSTOM
// RUN: not mlir-opt %s -pass-pipeline='func.func(test-pass-create-invalid-ir{emit-invalid-ir=true signal-pass-failure=false})' -mlir-print-ir-after-failure 2>&1 -mlir-print-assume-verified | FileCheck %s --check-prefix=CHECK-CUSTOM // RUN: not mlir-opt %s -pass-pipeline='builtin.module(func.func(test-pass-create-invalid-ir{emit-invalid-ir=true signal-pass-failure=false}))' -mlir-print-ir-after-failure 2>&1 -mlir-print-assume-verified | FileCheck %s --check-prefix=CHECK-CUSTOM
// Test whether we print generically or not on pass failure, depending on whether there is invalid IR or not. // Test whether we print generically or not on pass failure, depending on whether there is invalid IR or not.
// CHECK-CUSTOM: func @TestCreateInvalidCallInPass // CHECK-CUSTOM: func @TestCreateInvalidCallInPass
// CHECK-GENERIC: "func.func" // CHECK-GENERIC: "func.func"
func.func @TestCreateInvalidCallInPass() { func.func @TestCreateInvalidCallInPass() {
return return
} }

mlir/test/Pass/invalid-parent.mlir

// RUN: mlir-opt %s -pass-pipeline='func.func(test-pass-invalid-parent)' -verify-diagnostics // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(test-pass-invalid-parent))' -verify-diagnostics
// Test that we properly report errors when the parent becomes invalid after running a pass // Test that we properly report errors when the parent becomes invalid after running a pass
// on a child operation. // on a child operation.
// expected-error@below {{'some_unknown_func' does not reference a valid function}} // expected-error@below {{'some_unknown_func' does not reference a valid function}}
func.func @TestCreateInvalidCallInPass() { func.func @TestCreateInvalidCallInPass() {
return return
} }

mlir/test/Pass/invalid-pass.mlir

// RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass{test-option=a})' 2>&1 | FileCheck %s // RUN: not mlir-opt %s -pass-pipeline='builtin.module(builtin.module(test-module-pass{test-option=a}))' 2>&1 | FileCheck %s
// CHECK: <Pass-Options-Parser>: no such option test-option // CHECK: <Pass-Options-Parser>: no such option test-option
// CHECK: failed to add `test-module-pass` with options `test-option=a` // CHECK: failed to add `test-module-pass` with options `test-option=a`
// CHECK: failed to add `builtin.module` with options `` to inner pipeline // CHECK: failed to add `builtin.module` with options `` to inner pipeline
module {} module {}

mlir/test/Pass/ir-printing.mlir

// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -mlir-print-ir-before=cse -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE %s // RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.module(func.func(cse,canonicalize))' -mlir-print-ir-before=cse -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE %s
// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -mlir-print-ir-before-all -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_ALL %s // RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.module(func.func(cse,canonicalize))' -mlir-print-ir-before-all -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_ALL %s
// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -mlir-print-ir-after=cse -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER %s // RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.module(func.func(cse,canonicalize))' -mlir-print-ir-after=cse -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER %s
// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -mlir-print-ir-after-all -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL %s // RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.module(func.func(cse,canonicalize))' -mlir-print-ir-after-all -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL %s
// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -mlir-print-ir-before=cse -mlir-print-ir-module-scope -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_MODULE %s // RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.module(func.func(cse,canonicalize))' -mlir-print-ir-before=cse -mlir-print-ir-module-scope -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_MODULE %s
// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,cse)' -mlir-print-ir-after-all -mlir-print-ir-after-change -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL_CHANGE %s // RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.module(func.func(cse,cse))' -mlir-print-ir-after-all -mlir-print-ir-after-change -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL_CHANGE %s
// RUN: not mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,test-pass-failure)' -mlir-print-ir-after-failure -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_FAILURE %s // RUN: not mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.module(func.func(cse,test-pass-failure))' -mlir-print-ir-after-failure -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_FAILURE %s
func.func @foo() { func.func @foo() {
%0 = arith.constant 0 : i32 %0 = arith.constant 0 : i32
return return
} }
func.func @bar() { func.func @bar() {
return return
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

mlir/test/Pass/pass-timing.mlir

// RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='func.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=list 2>&1 | FileCheck -check-prefix=LIST %s // RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='builtin.module(func.func(cse,canonicalize,cse))' -mlir-timing -mlir-timing-display=list 2>&1 | FileCheck -check-prefix=LIST %s
// RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='func.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=PIPELINE %s // RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='builtin.module(func.func(cse,canonicalize,cse))' -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=PIPELINE %s
// RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='func.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=list 2>&1 | FileCheck -check-prefix=MT_LIST %s // RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='builtin.module(func.func(cse,canonicalize,cse))' -mlir-timing -mlir-timing-display=list 2>&1 | FileCheck -check-prefix=MT_LIST %s
// RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='func.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=MT_PIPELINE %s // RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='builtin.module(func.func(cse,canonicalize,cse))' -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=MT_PIPELINE %s
// RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=false -test-pm-nested-pipeline -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=NESTED_PIPELINE %s // RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=false -test-pm-nested-pipeline -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=NESTED_PIPELINE %s
// LIST: Execution time report // LIST: Execution time report
// LIST: Total Execution Time: // LIST: Total Execution Time:
// LIST: Name // LIST: Name
// LIST-DAG: Canonicalizer // LIST-DAG: Canonicalizer
// LIST-DAG: CSE // LIST-DAG: CSE
// LIST-DAG: DominanceInfo // LIST-DAG: DominanceInfo
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

mlir/test/Pass/pipeline-options-parsing.mlir

// RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass{)' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_1 %s // RUN: not mlir-opt %s -pass-pipeline='builtin.module(builtin.module(test-module-pass{))' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_1 %s
// RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass{test-option=3})' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_2 %s // RUN: not mlir-opt %s -pass-pipeline='builtin.module(builtin.module(test-module-pass{test-option=3}))' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_2 %s
// RUN: not mlir-opt %s -pass-pipeline='builtin.module(func.func(test-options-pass{list=3}), test-module-pass{invalid-option=3})' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_3 %s // RUN: not mlir-opt %s -pass-pipeline='builtin.module(builtin.module(func.func(test-options-pass{list=3}), test-module-pass{invalid-option=3}))' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_3 %s
// RUN: not mlir-opt %s -pass-pipeline='test-options-pass{list=3 list=notaninteger}' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_4 %s // RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-options-pass{list=3 list=notaninteger})' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_4 %s
// RUN: mlir-opt %s -pass-pipeline='func.func(test-options-pass{list=1,2,3,4 list=5 string=value1 string=value2})' // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(test-options-pass{list=1,2,3,4 list=5 string=value1 string=value2}))'
// RUN: mlir-opt %s -verify-each=false -pass-pipeline='func.func(test-options-pass{string-list=a list=1,2,3,4 string-list=b,c list=5 string-list=d string=nested_pipeline{arg1=10 arg2=" {} " arg3=true}})' -dump-pass-pipeline 2>&1 | FileCheck --check-prefix=CHECK_1 %s // RUN: mlir-opt %s -verify-each=false -pass-pipeline='builtin.module(func.func(test-options-pass{string-list=a list=1,2,3,4 string-list=b,c list=5 string-list=d string=nested_pipeline{arg1=10 arg2=" {} " arg3=true}}))' -dump-pass-pipeline 2>&1 | FileCheck --check-prefix=CHECK_1 %s
// RUN: mlir-opt %s -verify-each=false -test-options-pass-pipeline='list=1 string-list=a,b' -dump-pass-pipeline 2>&1 | FileCheck --check-prefix=CHECK_2 %s // RUN: mlir-opt %s -verify-each=false -test-options-pass-pipeline='list=1 string-list=a,b' -dump-pass-pipeline 2>&1 | FileCheck --check-prefix=CHECK_2 %s
// RUN: mlir-opt %s -verify-each=false -pass-pipeline='builtin.module(func.func(test-options-pass{list=3}), func.func(test-options-pass{list=1,2,3,4}))' -dump-pass-pipeline 2>&1 | FileCheck --check-prefix=CHECK_3 %s // RUN: mlir-opt %s -verify-each=false -pass-pipeline='builtin.module(builtin.module(func.func(test-options-pass{list=3}), func.func(test-options-pass{list=1,2,3,4})))' -dump-pass-pipeline 2>&1 | FileCheck --check-prefix=CHECK_3 %s
// CHECK_ERROR_1: missing closing '}' while processing pass options // CHECK_ERROR_1: missing closing '}' while processing pass options
// CHECK_ERROR_2: no such option test-option // CHECK_ERROR_2: no such option test-option
// CHECK_ERROR_3: no such option invalid-option // CHECK_ERROR_3: no such option invalid-option
// CHECK_ERROR_4: 'notaninteger' value invalid for integer argument // CHECK_ERROR_4: 'notaninteger' value invalid for integer argument
// CHECK_1: test-options-pass{list=1,2,3,4,5 string=nested_pipeline{arg1=10 arg2=" {} " arg3=true} string-list=a,b,c,d} // CHECK_1: test-options-pass{list=1,2,3,4,5 string=nested_pipeline{arg1=10 arg2=" {} " arg3=true} string-list=a,b,c,d}
// CHECK_2: test-options-pass{list=1 string= string-list=a,b} // CHECK_2: test-options-pass{list=1 string= string-list=a,b}
// CHECK_3: builtin.module(builtin.module(func.func(test-options-pass{list=3 string= }),func.func(test-options-pass{list=1,2,3,4 string= }))) // CHECK_3: builtin.module(builtin.module(func.func(test-options-pass{list=3 string= }),func.func(test-options-pass{list=1,2,3,4 string= })))

mlir/test/Pass/pipeline-parsing.mlir

// RUN: mlir-opt %s -mlir-disable-threading -pass-pipeline='builtin.module(test-module-pass,func.func(test-function-pass)),func.func(test-function-pass),func.func(cse,canonicalize)' -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s // RUN: mlir-opt %s -mlir-disable-threading -pass-pipeline='builtin.module(builtin.module(test-module-pass,func.func(test-function-pass)),func.func(test-function-pass),func.func(cse,canonicalize))' -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s
// RUN: mlir-opt %s -mlir-disable-threading -test-textual-pm-nested-pipeline -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s --check-prefix=TEXTUAL_CHECK // RUN: mlir-opt %s -mlir-disable-threading -test-textual-pm-nested-pipeline -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s --check-prefix=TEXTUAL_CHECK
// RUN: mlir-opt %s -mlir-disable-threading -pass-pipeline='builtin.module(test-module-pass),any(test-interface-pass),any(test-interface-pass),func.func(test-function-pass),any(canonicalize),func.func(cse)' -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s --check-prefix=GENERIC_MERGE_CHECK // RUN: mlir-opt %s -mlir-disable-threading -pass-pipeline='builtin.module(builtin.module(test-module-pass),any(test-interface-pass),any(test-interface-pass),func.func(test-function-pass),any(canonicalize),func.func(cse))' -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s --check-prefix=GENERIC_MERGE_CHECK
// RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_1 %s // RUN: not mlir-opt %s -pass-pipeline='any(builtin.module(test-module-pass)' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_1 %s
// RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass))' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_2 %s // RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass))' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_2 %s
// RUN: not mlir-opt %s -pass-pipeline='builtin.module()(' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_3 %s // RUN: not mlir-opt %s -pass-pipeline='any(builtin.module()()' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_3 %s
// RUN: not mlir-opt %s -pass-pipeline=',' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_4 %s // RUN: not mlir-opt %s -pass-pipeline='any(,)' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_4 %s
// RUN: not mlir-opt %s -pass-pipeline='func.func(test-module-pass)' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_5 %s // RUN: not mlir-opt %s -pass-pipeline='func.func(test-module-pass)' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_5 %s
// CHECK_ERROR_1: encountered unbalanced parentheses while parsing pipeline // CHECK_ERROR_1: encountered unbalanced parentheses while parsing pipeline
// CHECK_ERROR_2: encountered extra closing ')' creating unbalanced parentheses while parsing pipeline // CHECK_ERROR_2: encountered extra closing ')' creating unbalanced parentheses while parsing pipeline
// CHECK_ERROR_3: expected ',' after parsing pipeline // CHECK_ERROR_3: expected ',' after parsing pipeline
// CHECK_ERROR_4: does not refer to a registered pass or pass pipeline // CHECK_ERROR_4: does not refer to a registered pass or pass pipeline
// CHECK_ERROR_5: Can't add pass '{{.*}}TestModulePass' restricted to 'builtin.module' on a PassManager intended to run on 'func.func', did you intend to nest? // CHECK_ERROR_5: Can't add pass '{{.*}}TestModulePass' restricted to 'builtin.module' on a PassManager intended to run on 'func.func', did you intend to nest?
// RUN: not mlir-opt %s -pass-pipeline='' -cse 2>&1 | FileCheck --check-prefix=CHECK_ERROR_6 %s // RUN: not mlir-opt %s -pass-pipeline='' -cse 2>&1 | FileCheck --check-prefix=CHECK_ERROR_6 %s
// CHECK_ERROR_6: '-pass-pipeline' option can't be used with individual pass options // CHECK_ERROR_6: '-pass-pipeline' option can't be used with individual pass options
// RUN: not mlir-opt %s -pass-pipeline='wrong-op()' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_7 %s
// CHECK_ERROR_7: can't run 'wrong-op' pass manager on 'builtin.module' op
// RUN: mlir-opt %s -pass-pipeline='any(cse)' -dump-pass-pipeline 2>&1 | FileCheck %s -check-prefix=CHECK_ROUNDTRIP
// CHECK_ROUNDTRIP: any(cse)
func.func @foo() { func.func @foo() {
return return
} }
module { module {
func.func @foo() { func.func @foo() {
return return
} }
Show All 37 Lines

mlir/test/Pass/pipeline-stats.mlir

// REQUIRES: asserts // REQUIRES: asserts
// RUN: mlir-opt %s -verify-each=true -pass-pipeline='func.func(test-stats-pass,test-stats-pass)' -mlir-pass-statistics -mlir-pass-statistics-display=list 2>&1 | FileCheck -check-prefix=LIST %s // RUN: mlir-opt %s -verify-each=true -pass-pipeline='builtin.module(func.func(test-stats-pass,test-stats-pass))' -mlir-pass-statistics -mlir-pass-statistics-display=list 2>&1 | FileCheck -check-prefix=LIST %s
// RUN: mlir-opt %s -verify-each=true -pass-pipeline='func.func(test-stats-pass,test-stats-pass)' -mlir-pass-statistics -mlir-pass-statistics-display=pipeline 2>&1 | FileCheck -check-prefix=PIPELINE %s // RUN: mlir-opt %s -verify-each=true -pass-pipeline='builtin.module(func.func(test-stats-pass,test-stats-pass))' -mlir-pass-statistics -mlir-pass-statistics-display=pipeline 2>&1 | FileCheck -check-prefix=PIPELINE %s
// LIST: Pass statistics report // LIST: Pass statistics report
// LIST: TestStatisticPass // LIST: TestStatisticPass
// LIST-NEXT: (S) {{0|8}} num-ops - Number of operations counted // LIST-NEXT: (S) {{0|8}} num-ops - Number of operations counted
// LIST-NEXT: (S) {{0|8}} num-ops2 - Number of operations counted one more time // LIST-NEXT: (S) {{0|8}} num-ops2 - Number of operations counted one more time
// LIST-NOT: Verifier // LIST-NOT: Verifier
// PIPELINE: Pass statistics report // PIPELINE: Pass statistics report
Show All 15 Lines

mlir/test/Target/LLVMIR/arm-neon-2d.mlir

// RUN: mlir-opt -pass-pipeline="func.func(arm-neon-2d-to-intr)" %s | FileCheck %s // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(arm-neon-2d-to-intr))" %s | FileCheck %s
// CHECK-LABEL: arm_neon_sdot2d_4x4_i8i8 // CHECK-LABEL: arm_neon_sdot2d_4x4_i8i8
func.func @arm_neon_sdot2d_4x4_i8i8(%a: vector<4xi32>, %b: vector<4x4xi8>, %c: vector<4x4xi8>) -> vector<4xi32> { func.func @arm_neon_sdot2d_4x4_i8i8(%a: vector<4xi32>, %b: vector<4x4xi8>, %c: vector<4x4xi8>) -> vector<4xi32> {
// CHECK: arm_neon.intr.sdot %{{.*}}, %{{.*}}, %{{.*}} : vector<16xi8>, vector<16xi8> to vector<4xi32> // CHECK: arm_neon.intr.sdot %{{.*}}, %{{.*}}, %{{.*}} : vector<16xi8>, vector<16xi8> to vector<4xi32>
// CHECK-NEXT: return %{{.*}} : vector<4xi32> // CHECK-NEXT: return %{{.*}} : vector<4xi32>
%0 = arm_neon.2d.sdot %a, %b, %c : vector<4x4xi8>, vector<4x4xi8> to vector<4xi32> %0 = arm_neon.2d.sdot %a, %b, %c : vector<4x4xi8>, vector<4x4xi8> to vector<4xi32>
return %0 : vector<4xi32> return %0 : vector<4xi32>
} }
// CHECK-LABEL: arm_neon_sdot2d_2x4_i8i8 // CHECK-LABEL: arm_neon_sdot2d_2x4_i8i8
func.func @arm_neon_sdot2d_2x4_i8i8(%a: vector<2xi32>, %b: vector<2x4xi8>, %c: vector<2x4xi8>) -> vector<2xi32> { func.func @arm_neon_sdot2d_2x4_i8i8(%a: vector<2xi32>, %b: vector<2x4xi8>, %c: vector<2x4xi8>) -> vector<2xi32> {
// CHECK: arm_neon.intr.sdot %{{.*}}, %{{.*}}, %{{.*}} : vector<8xi8>, vector<8xi8> to vector<2xi32> // CHECK: arm_neon.intr.sdot %{{.*}}, %{{.*}}, %{{.*}} : vector<8xi8>, vector<8xi8> to vector<2xi32>
// CHECK-NEXT: return %{{.*}} : vector<2xi32> // CHECK-NEXT: return %{{.*}} : vector<2xi32>
%0 = arm_neon.2d.sdot %a, %b, %c : vector<2x4xi8>, vector<2x4xi8> to vector<2xi32> %0 = arm_neon.2d.sdot %a, %b, %c : vector<2x4xi8>, vector<2x4xi8> to vector<2xi32>
return %0 : vector<2xi32> return %0 : vector<2xi32>
} }

mlir/test/Target/LLVMIR/vector-to-llvm-ir.mlir

// RUN: mlir-opt %s -pass-pipeline="convert-vector-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" | mlir-translate -mlir-to-llvmir | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(convert-vector-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-translate -mlir-to-llvmir | FileCheck %s
func.func @genbool_1d() -> vector<8xi1> { func.func @genbool_1d() -> vector<8xi1> {
%0 = vector.constant_mask [4] : vector<8xi1> %0 = vector.constant_mask [4] : vector<8xi1>
return %0 : vector<8xi1> return %0 : vector<8xi1>
} }
// CHECK-LABEL: @genbool_1d() // CHECK-LABEL: @genbool_1d()
// CHECK-NEXT: ret <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 false, i1 false, i1 false, i1 false> // CHECK-NEXT: ret <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 false, i1 false, i1 false, i1 false>
Show All 22 Lines

mlir/test/Transforms/canonicalize-block-merge.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func.func(canonicalize)' -split-input-file | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.module(func.func(canonicalize))' -split-input-file | FileCheck %s
// Check the simple case of single operation blocks with a return. // Check the simple case of single operation blocks with a return.
// CHECK-LABEL: func @return_blocks( // CHECK-LABEL: func @return_blocks(
func.func @return_blocks() { func.func @return_blocks() {
// CHECK: "foo.cond_br"()[^bb1, ^bb1] // CHECK: "foo.cond_br"()[^bb1, ^bb1]
// CHECK: ^bb1: // CHECK: ^bb1:
// CHECK-NEXT: return // CHECK-NEXT: return
▲ Show 20 Lines • Show All 268 Lines • Show Last 20 Lines

mlir/test/Transforms/canonicalize-dce.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -pass-pipeline='func.func(canonicalize)' | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -pass-pipeline='builtin.module(func.func(canonicalize))' | FileCheck %s
// Test case: Simple case of deleting a dead pure op. // Test case: Simple case of deleting a dead pure op.
// CHECK: func @f(%arg0: f32) { // CHECK: func @f(%arg0: f32) {
// CHECK-NEXT: return // CHECK-NEXT: return
func.func @f(%arg0: f32) { func.func @f(%arg0: f32) {
%0 = "arith.addf"(%arg0, %arg0) : (f32, f32) -> f32 %0 = "arith.addf"(%arg0, %arg0) : (f32, f32) -> f32
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

mlir/test/Transforms/canonicalize-td.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func.func(canonicalize{top-down=true})' | FileCheck %s --check-prefix=TD // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.module(func.func(canonicalize{top-down=true}))' | FileCheck %s --check-prefix=TD
// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func.func(canonicalize)' | FileCheck %s --check-prefix=BU // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.module(func.func(canonicalize))' | FileCheck %s --check-prefix=BU
// BU-LABEL: func @default_insertion_position // BU-LABEL: func @default_insertion_position
// TD-LABEL: func @default_insertion_position // TD-LABEL: func @default_insertion_position
func.func @default_insertion_position(%cond: i1) { func.func @default_insertion_position(%cond: i1) {
// Constant should be folded into the entry block. // Constant should be folded into the entry block.
// BU: arith.constant 2 // BU: arith.constant 2
Show All 31 Lines

mlir/test/Transforms/canonicalize.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func.func(canonicalize)' -split-input-file | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.module(func.func(canonicalize))' -split-input-file | FileCheck %s
// CHECK-LABEL: func @test_subi_zero // CHECK-LABEL: func @test_subi_zero
func.func @test_subi_zero(%arg0: i32) -> i32 { func.func @test_subi_zero(%arg0: i32) -> i32 {
// CHECK-NEXT: %c0_i32 = arith.constant 0 : i32 // CHECK-NEXT: %c0_i32 = arith.constant 0 : i32
// CHECK-NEXT: return %c0 // CHECK-NEXT: return %c0
%y = arith.subi %arg0, %arg0 : i32 %y = arith.subi %arg0, %arg0 : i32
return %y: i32 return %y: i32
} }
▲ Show 20 Lines • Show All 1,222 Lines • Show Last 20 Lines

mlir/test/Transforms/cse.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func.func(cse)' | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.module(func.func(cse))' | FileCheck %s
// CHECK-DAG: #[[$MAP:.*]] = affine_map<(d0) -> (d0 mod 2)> // CHECK-DAG: #[[$MAP:.*]] = affine_map<(d0) -> (d0 mod 2)>
#map0 = affine_map<(d0) -> (d0 mod 2)> #map0 = affine_map<(d0) -> (d0 mod 2)>
// CHECK-LABEL: @simple_constant // CHECK-LABEL: @simple_constant
func.func @simple_constant() -> (i32, i32) { func.func @simple_constant() -> (i32, i32) {
// CHECK-NEXT: %[[VAR_c1_i32:.*]] = arith.constant 1 : i32 // CHECK-NEXT: %[[VAR_c1_i32:.*]] = arith.constant 1 : i32
%0 = arith.constant 1 : i32 %0 = arith.constant 1 : i32
▲ Show 20 Lines • Show All 315 Lines • Show Last 20 Lines

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

// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func.func(scf-parallel-loop-collapsing{collapsed-indices-0=0,3 collapsed-indices-1=1,4 collapsed-indices-2=2}, canonicalize)' | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.module(func.func(scf-parallel-loop-collapsing{collapsed-indices-0=0,3 collapsed-indices-1=1,4 collapsed-indices-2=2}, canonicalize))' | FileCheck %s
// CHECK-LABEL: func @parallel_many_dims() { // CHECK-LABEL: func @parallel_many_dims() {
func.func @parallel_many_dims() { func.func @parallel_many_dims() {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%c3 = arith.constant 3 : index %c3 = arith.constant 3 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
Show All 37 Lines

mlir/test/Transforms/parametric-mapping.mlir

// RUN: mlir-opt -allow-unregistered-dialect -pass-pipeline="func.func(test-mapping-to-processing-elements)" %s | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect -pass-pipeline="builtin.module(func.func(test-mapping-to-processing-elements))" %s | FileCheck %s
// CHECK: #[[mul_map:.+]] = affine_map<()[s0, s1] -> (s0 * s1)> // CHECK: #[[mul_map:.+]] = affine_map<()[s0, s1] -> (s0 * s1)>
// CHECK: #[[add_map:.+]] = affine_map<()[s0, s1] -> (s0 + s1)> // CHECK: #[[add_map:.+]] = affine_map<()[s0, s1] -> (s0 + s1)>
// CHECK: func @map1d // CHECK: func @map1d
// CHECK-SAME: (%[[lb:.*]]: index, %[[ub:.*]]: index, %[[step:.*]]: index) // CHECK-SAME: (%[[lb:.*]]: index, %[[ub:.*]]: index, %[[step:.*]]: index)
func.func @map1d(%lb: index, %ub: index, %step: index) { func.func @map1d(%lb: index, %ub: index, %step: index) {
// CHECK: %[[threads:.*]]:2 = "new_processor_id_and_range"() : () -> (index, index) // CHECK: %[[threads:.*]]:2 = "new_processor_id_and_range"() : () -> (index, index)
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

mlir/test/Transforms/sccp-callgraph.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -sccp -split-input-file | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s -sccp -split-input-file | FileCheck %s
// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="builtin.module(sccp)" -split-input-file | FileCheck %s --check-prefix=NESTED // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="builtin.module(builtin.module(sccp))" -split-input-file | FileCheck %s --check-prefix=NESTED
// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="func.func(sccp)" -split-input-file | FileCheck %s --check-prefix=FUNC // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="builtin.module(func.func(sccp))" -split-input-file | FileCheck %s --check-prefix=FUNC
/// Check that a constant is properly propagated through the arguments and /// Check that a constant is properly propagated through the arguments and
/// results of a private function. /// results of a private function.
// CHECK-LABEL: func private @private( // CHECK-LABEL: func private @private(
func.func private @private(%arg0 : i32) -> i32 { func.func private @private(%arg0 : i32) -> i32 {
// CHECK: %[[CST:.*]] = arith.constant 1 : i32 // CHECK: %[[CST:.*]] = arith.constant 1 : i32
// CHECK: return %[[CST]] : i32 // CHECK: return %[[CST]] : i32
▲ Show 20 Lines • Show All 297 Lines • Show Last 20 Lines

mlir/test/Transforms/sccp-structured.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="func.func(sccp)" -split-input-file | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="builtin.module(func.func(sccp))" -split-input-file | FileCheck %s
/// Check that a constant is properly propagated when only one edge is taken. /// Check that a constant is properly propagated when only one edge is taken.
// CHECK-LABEL: func @simple( // CHECK-LABEL: func @simple(
func.func @simple(%arg0 : i32) -> i32 { func.func @simple(%arg0 : i32) -> i32 {
// CHECK: %[[CST:.*]] = arith.constant 1 : i32 // CHECK: %[[CST:.*]] = arith.constant 1 : i32
// CHECK-NOT: scf.if // CHECK-NOT: scf.if
// CHECK: return %[[CST]] : i32 // CHECK: return %[[CST]] : i32
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

mlir/test/Transforms/sccp.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="func.func(sccp)" -split-input-file | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="builtin.module(func.func(sccp))" -split-input-file | FileCheck %s
/// Check simple forward constant propagation without any control flow. /// Check simple forward constant propagation without any control flow.
// CHECK-LABEL: func @no_control_flow // CHECK-LABEL: func @no_control_flow
func.func @no_control_flow(%arg0: i32) -> i32 { func.func @no_control_flow(%arg0: i32) -> i32 {
// CHECK: %[[CST:.*]] = arith.constant 1 : i32 // CHECK: %[[CST:.*]] = arith.constant 1 : i32
// CHECK: return %[[CST]] : i32 // CHECK: return %[[CST]] : i32
▲ Show 20 Lines • Show All 239 Lines • Show Last 20 Lines

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

// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func.func(scf-parallel-loop-collapsing{collapsed-indices-0=0,1}, canonicalize)' | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.module(func.func(scf-parallel-loop-collapsing{collapsed-indices-0=0,1}, canonicalize))' | FileCheck %s
func.func @collapse_to_single() { func.func @collapse_to_single() {
%c0 = arith.constant 3 : index %c0 = arith.constant 3 : index
%c1 = arith.constant 7 : index %c1 = arith.constant 7 : index
%c2 = arith.constant 11 : index %c2 = arith.constant 11 : index
%c3 = arith.constant 29 : index %c3 = arith.constant 29 : index
%c4 = arith.constant 3 : index %c4 = arith.constant 3 : index
%c5 = arith.constant 4 : index %c5 = arith.constant 4 : index
Show All 25 Lines

mlir/test/Transforms/test-canonicalize-filter.mlir

// RUN: mlir-opt %s -pass-pipeline='func.func(canonicalize)' | FileCheck %s --check-prefix=NO_FILTER // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(canonicalize))' | FileCheck %s --check-prefix=NO_FILTER
// RUN: mlir-opt %s -pass-pipeline='func.func(canonicalize{enable-patterns=TestRemoveOpWithInnerOps})' | FileCheck %s --check-prefix=FILTER_ENABLE // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(canonicalize{enable-patterns=TestRemoveOpWithInnerOps}))' | FileCheck %s --check-prefix=FILTER_ENABLE
// RUN: mlir-opt %s -pass-pipeline='func.func(canonicalize{disable-patterns=TestRemoveOpWithInnerOps})' | FileCheck %s --check-prefix=FILTER_DISABLE // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(canonicalize{disable-patterns=TestRemoveOpWithInnerOps}))' | FileCheck %s --check-prefix=FILTER_DISABLE
// NO_FILTER-LABEL: func @remove_op_with_inner_ops_pattern // NO_FILTER-LABEL: func @remove_op_with_inner_ops_pattern
// NO_FILTER-NEXT: return // NO_FILTER-NEXT: return
// FILTER_ENABLE-LABEL: func @remove_op_with_inner_ops_pattern // FILTER_ENABLE-LABEL: func @remove_op_with_inner_ops_pattern
// FILTER_ENABLE-NEXT: return // FILTER_ENABLE-NEXT: return
// FILTER_DISABLE-LABEL: func @remove_op_with_inner_ops_pattern // FILTER_DISABLE-LABEL: func @remove_op_with_inner_ops_pattern
// FILTER_DISABLE-NEXT: "test.op_with_region_pattern"() // FILTER_DISABLE-NEXT: "test.op_with_region_pattern"()
func.func @remove_op_with_inner_ops_pattern() { func.func @remove_op_with_inner_ops_pattern() {
"test.op_with_region_pattern"() ({ "test.op_with_region_pattern"() ({
"test.op_with_region_terminator"() : () -> () "test.op_with_region_terminator"() : () -> ()
}) : () -> () }) : () -> ()
return return
} }

mlir/test/Transforms/test-canonicalize.mlir

// RUN: mlir-opt %s -pass-pipeline='func.func(canonicalize)' | FileCheck %s // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(canonicalize))' | FileCheck %s
// RUN: mlir-opt %s -pass-pipeline='func.func(canonicalize{region-simplify=false})' | FileCheck %s --check-prefixes=CHECK,NO-RS // RUN: mlir-opt %s -pass-pipeline='builtin.module(func.func(canonicalize{region-simplify=false}))' | FileCheck %s --check-prefixes=CHECK,NO-RS
// CHECK-LABEL: func @remove_op_with_inner_ops_pattern // CHECK-LABEL: func @remove_op_with_inner_ops_pattern
func.func @remove_op_with_inner_ops_pattern() { func.func @remove_op_with_inner_ops_pattern() {
// CHECK-NEXT: return // CHECK-NEXT: return
"test.op_with_region_pattern"() ({ "test.op_with_region_pattern"() ({
"test.op_with_region_terminator"() : () -> () "test.op_with_region_terminator"() : () -> ()
}) : () -> () }) : () -> ()
return return
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

mlir/test/Transforms/test-operation-folder-commutative.mlir

// RUN: mlir-opt --pass-pipeline="func.func(test-patterns)" %s | FileCheck %s // RUN: mlir-opt --pass-pipeline="builtin.module(func.func(test-patterns))" %s | FileCheck %s
// CHECK-LABEL: func @test_reorder_constants_and_match // CHECK-LABEL: func @test_reorder_constants_and_match
func.func @test_reorder_constants_and_match(%arg0 : i32) -> (i32) { func.func @test_reorder_constants_and_match(%arg0 : i32) -> (i32) {
// CHECK: %[[CST:.+]] = arith.constant 43 // CHECK: %[[CST:.+]] = arith.constant 43
%cst = arith.constant 43 : i32 %cst = arith.constant 43 : i32
// CHECK: return %[[CST]] // CHECK: return %[[CST]]
%y = "test.op_commutative2"(%cst, %arg0) : (i32, i32) -> i32 %y = "test.op_commutative2"(%cst, %arg0) : (i32, i32) -> i32
%x = "test.op_commutative2"(%y, %arg0) : (i32, i32) -> i32 %x = "test.op_commutative2"(%y, %arg0) : (i32, i32) -> i32
return %x : i32 return %x : i32
} }

mlir/test/Transforms/test-symbol-dce.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -symbol-dce -split-input-file -verify-diagnostics | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s -symbol-dce -split-input-file -verify-diagnostics | FileCheck %s
// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="builtin.module(symbol-dce)" -split-input-file | FileCheck %s --check-prefix=NESTED // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="builtin.module(builtin.module(symbol-dce))" -split-input-file | FileCheck %s --check-prefix=NESTED
// Check that trivially dead and trivially live non-nested cases are handled. // Check that trivially dead and trivially live non-nested cases are handled.
// CHECK-LABEL: module attributes {test.simple} // CHECK-LABEL: module attributes {test.simple}
module attributes {test.simple} { module attributes {test.simple} {
// CHECK-NOT: func private @dead_private_function // CHECK-NOT: func private @dead_private_function
func.func private @dead_private_function() func.func private @dead_private_function()
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/async-error.mlir

// RUN: mlir-opt %s -pass-pipeline="async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,convert-vector-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,convert-vector-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e main -entry-point-result=void -O0 \ // RUN: -e main -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// FIXME: https://github.com/llvm/llvm-project/issues/57231 // FIXME: https://github.com/llvm/llvm-project/issues/57231
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/async-group.mlir

// RUN: mlir-opt %s -pass-pipeline="async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e main -entry-point-result=void -O0 \ // RUN: -e main -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// This is crashing in CI "most of the time" on a AMD Rome CPU VM on GCP with: // This is crashing in CI "most of the time" on a AMD Rome CPU VM on GCP with:
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/async-value.mlir

// RUN: mlir-opt %s -pass-pipeline="async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-arith-to-llvm),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-arith-to-llvm),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e main -entry-point-result=void -O0 \ // RUN: -e main -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// FIXME: https://github.com/llvm/llvm-project/issues/57231 // FIXME: https://github.com/llvm/llvm-project/issues/57231
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/async.mlir

// RUN: mlir-opt %s -pass-pipeline="async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,convert-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,convert-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e main -entry-point-result=void -O0 \ // RUN: -e main -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// FIXME: https://github.com/llvm/llvm-project/issues/57231 // FIXME: https://github.com/llvm/llvm-project/issues/57231
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/bare-ptr-call-conv.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-scf-to-cf,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm{use-bare-ptr-memref-call-conv=1},reconcile-unrealized-casts" | mlir-cpu-runner -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext -entry-point-result=void | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-scf-to-cf,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm{use-bare-ptr-memref-call-conv=1},reconcile-unrealized-casts)" | mlir-cpu-runner -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext -entry-point-result=void | FileCheck %s
// Verify bare pointer memref calling convention. `simple_add1_add2_test` // Verify bare pointer memref calling convention. `simple_add1_add2_test`
// gets two 2xf32 memrefs, adds 1.0f to the first one and 2.0f to the second // gets two 2xf32 memrefs, adds 1.0f to the first one and 2.0f to the second
// one. 'main' calls 'simple_add1_add2_test' with {1, 1} and {2, 2} so {2, 2} // one. 'main' calls 'simple_add1_add2_test' with {1, 1} and {2, 2} so {2, 2}
// and {4, 4} are the expected outputs. // and {4, 4} are the expected outputs.
func.func @simple_add1_add2_test(%arg0: memref<2xf32>, %arg1: memref<2xf32>) { func.func @simple_add1_add2_test(%arg0: memref<2xf32>, %arg1: memref<2xf32>) {
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/copy.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-scf-to-cf,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-scf-to-cf,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | mlir-cpu-runner -e main -entry-point-result=void \ // RUN: | mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface } func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
func.func @main() -> () { func.func @main() -> () {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/global-memref.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e main -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-cpu-runner -e main -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface } func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
func.func private @printMemrefI32(memref<*xi32>) attributes { llvm.emit_c_interface } func.func private @printMemrefI32(memref<*xi32>) attributes { llvm.emit_c_interface }
func.func private @printNewline() -> () func.func private @printNewline() -> ()
memref.global "private" @gv0 : memref<4xf32> = dense<[0.0, 1.0, 2.0, 3.0]> memref.global "private" @gv0 : memref<4xf32> = dense<[0.0, 1.0, 2.0, 3.0]>
func.func @test1DMemref() { func.func @test1DMemref() {
%0 = memref.get_global @gv0 : memref<4xf32> %0 = memref.get_global @gv0 : memref<4xf32>
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/math-polynomial-approx.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(test-math-polynomial-approximation,convert-arith-to-llvm),convert-vector-to-llvm,func.func(convert-math-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(test-math-polynomial-approximation,convert-arith-to-llvm),convert-vector-to-llvm,func.func(convert-math-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e main -entry-point-result=void -O0 \ // RUN: -e main -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// -------------------------------------------------------------------------- // // -------------------------------------------------------------------------- //
// Tanh. // Tanh.
▲ Show 20 Lines • Show All 575 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/memref-reinterpret-cast.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-scf-to-cf),convert-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-scf-to-cf),convert-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | mlir-cpu-runner -e main -entry-point-result=void \ // RUN: | mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface } func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
func.func @main() -> () { func.func @main() -> () {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/memref-reshape.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-scf-to-cf,memref-expand,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-scf-to-cf,memref-expand,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | mlir-cpu-runner -e main -entry-point-result=void \ // RUN: | mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface } func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
func.func @main() -> () { func.func @main() -> () {
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/print.mlir

// RUN: mlir-opt %s -pass-pipeline="convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | mlir-cpu-runner -e main -entry-point-result=void \ // RUN: | mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
llvm.mlir.global internal constant @str_global("String to print\0A") llvm.mlir.global internal constant @str_global("String to print\0A")
llvm.func @printCString(!llvm.ptr<i8>) llvm.func @printCString(!llvm.ptr<i8>)
Show All 10 Lines

mlir/test/mlir-cpu-runner/sgemm-naive-codegen.mlir

// RUN: mlir-opt -pass-pipeline="func.func(convert-linalg-to-loops,lower-affine,convert-scf-to-cf,convert-arith-to-llvm),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" %s | mlir-cpu-runner -O3 -e main -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,lower-affine,convert-scf-to-cf,convert-arith-to-llvm),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" %s | mlir-cpu-runner -O3 -e main -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
func.func @main() { func.func @main() {
%A = memref.alloc() : memref<16x16xf32> %A = memref.alloc() : memref<16x16xf32>
%B = memref.alloc() : memref<16x16xf32> %B = memref.alloc() : memref<16x16xf32>
%C = memref.alloc() : memref<16x16xf32> %C = memref.alloc() : memref<16x16xf32>
%cf1 = arith.constant 1.00000e+00 : f32 %cf1 = arith.constant 1.00000e+00 : f32
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/unranked-memref.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
// CHECK: rank = 2 // CHECK: rank = 2
// CHECK-SAME: sizes = [10, 3] // CHECK-SAME: sizes = [10, 3]
// CHECK-SAME: strides = [3, 1] // CHECK-SAME: strides = [3, 1]
// CHECK-COUNT-10: [10, 10, 10] // CHECK-COUNT-10: [10, 10, 10]
// //
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/utils.mlir

// RUN: mlir-opt %s -pass-pipeline="func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e print_0d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-0D // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-cpu-runner -e print_0d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-0D
// RUN: mlir-opt %s -pass-pipeline="func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e print_1d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-1D // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-cpu-runner -e print_1d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-1D
// RUN: mlir-opt %s -pass-pipeline="func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e print_3d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-3D // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-cpu-runner -e print_3d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-3D
// RUN: mlir-opt %s -pass-pipeline="func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e vector_splat_2d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-VECTOR-SPLAT-2D // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-cpu-runner -e vector_splat_2d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-VECTOR-SPLAT-2D
func.func @print_0d() { func.func @print_0d() {
%f = arith.constant 2.00000e+00 : f32 %f = arith.constant 2.00000e+00 : f32
%A = memref.alloc() : memref<f32> %A = memref.alloc() : memref<f32>
memref.store %f, %A[]: memref<f32> memref.store %f, %A[]: memref<f32>
%U = memref.cast %A : memref<f32> to memref<*xf32> %U = memref.cast %A : memref<f32> to memref<*xf32>
call @printMemrefF32(%U): (memref<*xf32>) -> () call @printMemrefF32(%U): (memref<*xf32>) -> ()
memref.dealloc %A : memref<f32> memref.dealloc %A : memref<f32>
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

mlir/test/mlir-opt/async.mlir

// Check if mlir marks the corresponding function with required coroutine attribute. // Check if mlir marks the corresponding function with required coroutine attribute.
// //
// RUN: mlir-opt %s -pass-pipeline="async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,convert-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,convert-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// CHECK: llvm.func @async_execute_fn{{.*}}attributes{{.*}}presplitcoroutine // CHECK: llvm.func @async_execute_fn{{.*}}attributes{{.*}}presplitcoroutine
// CHECK: llvm.func @async_execute_fn_0{{.*}}attributes{{.*}}presplitcoroutine // CHECK: llvm.func @async_execute_fn_0{{.*}}attributes{{.*}}presplitcoroutine
// CHECK: llvm.func @async_execute_fn_1{{.*}}attributes{{.*}}presplitcoroutine // CHECK: llvm.func @async_execute_fn_1{{.*}}attributes{{.*}}presplitcoroutine
func.func @main() { func.func @main() {
%i0 = arith.constant 0 : index %i0 = arith.constant 0 : index
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines