This is an archive of the discontinued LLVM Phabricator instance.

Differential D118966

[mlir] Split out a new ControlFlow dialect from Standard
ClosedPublic

Authored by rriddle on Feb 3 2022, 9:01 PM.

Details

Reviewers
lebedev.ri
antiagainst
ftynse
aartbik
bondhugula
nicolasvasilache
herhut
mehdi_amini
stellaraccident
awarzynski
Commits
rGace01605e04d: [mlir] Split out a new ControlFlow dialect from Standard
Summary

This dialect is intended to model lower level/branch based control-flow constructs. The initial set
of operations are: AssertOp, BranchOp, CondBranchOp, SwitchOp; all split out from the current
standard dialect.

See https://discourse.llvm.org/t/standard-dialect-the-final-chapter/6061

Diff Detail

Event Timeline

rriddle created this revision.Feb 3 2022, 9:01 PM
Herald added a reviewer: lebedev.ri. · View Herald TranscriptFeb 3 2022, 9:01 PM
Herald added a reviewer: antiagainst. · View Herald Transcript
Herald added a reviewer: ftynse. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: bondhugula. · View Herald Transcript
Herald added subscribers: awarzynski, sdasgup3, wenzhicui and 26 others. · View Herald Transcript
rriddle requested review of this revision.Feb 3 2022, 9:01 PM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptFeb 3 2022, 9:01 PM
Herald added a reviewer: herhut. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
rriddle added a child revision: D118967: [mlir] Fixup test cases after splitting out a ControlFlow dialect.Feb 3 2022, 9:01 PM
rriddle mentioned this in D118967: [mlir] Fixup test cases after splitting out a ControlFlow dialect.Feb 3 2022, 9:01 PM

I split out the huge number of tests updated into D118967 to make this one easier to review, but I'll squash when actually committing.

Harbormaster completed remote builds in B147559: Diff 405866.Feb 3 2022, 9:20 PM
Mogball added a subscriber: Mogball.Feb 3 2022, 9:45 PM

I bet you're happy to be unshackled from integration

mlir/include/mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRV.h
17

Is this the right include?

mlir/include/mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h
14

Unused include?

18–19
mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp
98

Super or Base?

rriddle added a reviewer: mehdi_amini.Feb 4 2022, 11:00 AM
stellaraccident added a subscriber: stellaraccident.Feb 4 2022, 2:46 PM

We've got a number of python users of these ops. Would you accept some additions to enable python bindings for the cf dialect to land with this? If you've got a branch somewhere, I can just push a commit to that.

rriddle added a comment.Feb 5 2022, 3:57 PM
In D118966#3298176, @stellaraccident wrote:

We've got a number of python users of these ops. Would you accept some additions to enable python bindings for the cf dialect to land with this? If you've got a branch somewhere, I can just push a commit to that.

Ah, that would be nice (I know little to nothing about the python stuff). I've been pushing this to https://github.com/River707/llvm-project/tree/cleanup.

stellaraccident added a comment.Feb 5 2022, 4:32 PM

Cool - I'll send you a PR against that branch tonight or tomorrow and you can take it from there. Just boilerplate...

stellaraccident added subscribers: burmako, dmgreen, herhut and 11 others.Feb 5 2022, 9:54 PM

Here you go: https://github.com/River707/llvm-project/pull/1 (you should
just be able to merge that into your fork or pick it manually)

You had a failing Python test because of the move, and that is fixed now.

stellaraccident accepted this revision.Feb 5 2022, 11:20 PM

Generally, LGTM. A few minor comments.

mlir/docs/DialectConversion.md
118

I am so glad to have these properly namespaced now.

mlir/include/mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRV.h
17

Seems like we should just not include anything and forward declare RewritePatternSet (that is what ControlFlowToLLVM does)

mlir/include/mlir/Conversion/Passes.td
188

Does this really need to be a Module-pass? The Standard->* passes look like they were all Module-passes, but I wonder how much that is legacy and doesn't apply to a more focused dialect.

mlir/lib/Target/Cpp/TranslateToCpp.cpp
25

Isn't this supposed to be sorted to a come first in a block by itself?

This revision is now accepted and ready to land.Feb 5 2022, 11:20 PM
rriddle marked 8 inline comments as done.Feb 6 2022, 1:53 PM
rriddle added inline comments.
mlir/include/mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRV.h
17

Yep, thanks for pointing all of these out (just copied from the original file, which should also be doing the same)

mlir/include/mlir/Conversion/Passes.td
188

Yep, AssertOp may insert a function as part of the lowering (which requires updating the module).

mlir/lib/Target/Cpp/TranslateToCpp.cpp
25

No, system includes are supposed to come last:

https://llvm.org/docs/CodingStandards.html#include-style

kiranchandramohan added a subscriber: kiranchandramohan.Feb 6 2022, 2:24 PM

Just a drive-by comment, I think the flang changes are missing.

rriddle marked 3 inline comments as done.Feb 6 2022, 2:29 PM
In D118966#3299681, @kiranchandramohan wrote:

Just a drive-by comment, I think the flang changes are missing.

Yep, thanks. I have those fixups and will squash them in when landing.

This revision was landed with ongoing or failed builds.Feb 6 2022, 2:52 PM
Closed by commit rGace01605e04d: [mlir] Split out a new ControlFlow dialect from Standard (authored by rriddle). · Explain Why
This revision was automatically updated to reflect the committed changes.
rriddle added a commit: rGace01605e04d: [mlir] Split out a new ControlFlow dialect from Standard.
Herald added a reviewer: awarzynski. · View Herald TranscriptFeb 6 2022, 2:52 PM
Herald added a project: Restricted Project. · View Herald Transcript
jpienaar added a comment.Feb 6 2022, 4:49 PM

I'm seeing the following test failure

mlir/test/Integration/GPU/CUDA/TensorCore/wmma-matmul-f16.mlir:26:3: error: type mismatch for bb argument #0 of successor #0
  scf.for %arg0 = %c0 to %c16 step %c1 {
  ^

in one build.

Herald added a subscriber: jdoerfert. · View Herald TranscriptFeb 6 2022, 4:49 PM
rriddle added a comment.Feb 6 2022, 4:51 PM
In D118966#3299764, @jpienaar wrote:

I'm seeing the following test failure

mlir/test/Integration/GPU/CUDA/TensorCore/wmma-matmul-f16.mlir:26:3: error: type mismatch for bb argument #0 of successor #0
  scf.for %arg0 = %c0 to %c16 step %c1 {
  ^

in one build.

Should already be fixed at head.

awarzynski mentioned this in D118985: [flang][driver] Add support for `-emit-mlir`.Feb 7 2022, 3:19 AM

Revision Contents

PathSize
flang/
include/
flang/
Optimizer/
Support/
4 lines
Tools/
4 lines
lib/
Lower/
2 lines
Optimizer/
CodeGen/
3 lines
Transforms/
11 lines
36 lines
test/
Fir/
Todo/
4 lines
14 lines
12 lines
tools/
bbc/
2 lines
1 line
fir-opt/
2 lines
tco/
2 lines
1 line
mlir/
benchmark/
python/
2 lines
docs/
70 lines
2 lines
4 lines
Dialects/
5 lines
12 lines
16 lines
Rationale/
10 lines
Tutorials/
Toy/
5 lines
includes/
img/
2 lines
2 lines
examples/
toy/
Ch6/
mlir/
6 lines
Ch7/
mlir/
6 lines
include/
mlir/
Conversion/
ControlFlowToLLVM/
35 lines
ControlFlowToSPIRV/
28 lines
4 lines
46 lines
SCFToControlFlow/
28 lines
SCFToStandard/
Dialect/
Bufferization/
Transforms/
12 lines
1 line
ControlFlow/
1 line
IR/
2 lines
21 lines
30 lines
ControlFlow/
IR/
StandardOps/
IR/
274 lines
SCF/
6 lines
StandardOps/
IR/
3 lines
279 lines
2 lines
lib/
Conversion/
4 lines
ControlFlowToLLVM/
21 lines
148 lines
ControlFlowToSPIRV/
StandardToSPIRV/
11 lines
ControlFlowToSPIRV/
73 lines
GPUToNVVM/
5 lines
LinalgToLLVM/
2 lines
2 lines
MemRefToLLVM/
4 lines
OpenMPToLLVM/
4 lines
4 lines
SCFToControlFlow/
SCFToStandard/
7 lines
SCFToControlFlow.cpp
SCFToStandard.cpp
94 lines
SCFToStandard/
ShapeToStandard/
3 lines
StandardToLLVM/
1 line
81 lines
StandardToSPIRV/
1 line
46 lines
5 lines
Dialect/
Async/
Transforms/
15 lines
66 lines
2 lines
Bufferization/
Transforms/
6 lines
1 line
ControlFlow/
1 line
IR/
15 lines
ControlFlow/
IR/
StandardOps/
IR/
225 lines
GPU/
Transforms/
22 lines
3 lines
Linalg/
Transforms/
5 lines
SCF/
19 lines
SparseTensor/
Pipelines/
2 lines
2 lines
StandardOps/
1 line
IR/
816 lines
Target/
Cpp/
2 lines
18 lines
test/
Analysis/
8 lines
18 lines
32 lines
CAPI/
6 lines
Conversion/
AsyncToLLVM/
4 lines
ControlFlowToSPIRV/
41 lines
GPUToNVVM/
6 lines
OpenMPToLLVM/
6 lines
SCFToControlFlow/
SCFToStandard/
200 lines
SCFToStandard/
ShapeToStandard/
6 lines
StandardToLLVM/
2 lines
6 lines
68 lines
StandardToSPIRV/
42 lines
Dialect/
Affine/
4 lines
Async/
62 lines
62 lines
20 lines
Bufferization/
Transforms/
170 lines
ControlFlow/
Standard/
canonicalize.mlir
canonicalize-cf.mlir
132 lines
invalid.mlir
parser.mlir
8 lines
18 lines
GPU/
84 lines
84 lines
2 lines
Linalg/
4 lines
2 lines
8 lines
42 lines
18 lines
18 lines
12 lines
OpenMP/
14 lines
SCF/
26 lines
4 lines
4 lines
Standard/
22 lines
6 lines
IR/
40 lines
57 lines
4 lines
6 lines
20 lines
Integration/
Dialect/
Async/
CPU/
4 lines
6 lines
8 lines
6 lines
Linalg/
CPU/
2 lines
4 lines
2 lines
2 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
2 lines
2 lines
2 lines
8 lines
Memref/
2 lines
SparseTensor/
taco/
tools/
2 lines
Standard/
CPU/
2 lines
Vector/
CPU/
AMX/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
X86Vector/
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
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
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
8 lines
8 lines
4 lines
4 lines
2 lines
2 lines
4 lines
GPU/
CUDA/
TensorCore/
2 lines
2 lines
4 lines
ROCM/
2 lines
2 lines
Target/
Cpp/
12 lines
2 lines
Transforms/
120 lines
24 lines
54 lines
20 lines
2 lines
8 lines
24 lines
18 lines
4 lines
68 lines
6 lines
44 lines
6 lines
mlir-cpu-runner/
10 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
mlir-lsp-server/
2 lines
mlir-opt/
2 lines
1 line
mlir-reduce/
6 lines
6 lines
python/
12 lines
integration/
dialects/
linalg/
2 lines
ir/
4 lines
4 lines

Diff 406293

flang/include/flang/Optimizer/Support/InitFIR.h

Show All 21 Lines
#include "mlir/Transforms/LocationSnapshot.h" #include "mlir/Transforms/LocationSnapshot.h"
#include "mlir/Transforms/Passes.h" #include "mlir/Transforms/Passes.h"
namespace fir::support { namespace fir::support {
#define FLANG_NONCODEGEN_DIALECT_LIST \ #define FLANG_NONCODEGEN_DIALECT_LIST \
mlir::AffineDialect, FIROpsDialect, mlir::acc::OpenACCDialect, \ mlir::AffineDialect, FIROpsDialect, mlir::acc::OpenACCDialect, \
mlir::omp::OpenMPDialect, mlir::scf::SCFDialect, \ mlir::omp::OpenMPDialect, mlir::scf::SCFDialect, \
mlir::arith::ArithmeticDialect, mlir::StandardOpsDialect, \ mlir::arith::ArithmeticDialect, mlir::cf::ControlFlowDialect, \
mlir::vector::VectorDialect mlir::StandardOpsDialect, mlir::vector::VectorDialect
// The definitive list of dialects used by flang. // The definitive list of dialects used by flang.
#define FLANG_DIALECT_LIST \ #define FLANG_DIALECT_LIST \
FLANG_NONCODEGEN_DIALECT_LIST, FIRCodeGenDialect, mlir::LLVM::LLVMDialect FLANG_NONCODEGEN_DIALECT_LIST, FIRCodeGenDialect, mlir::LLVM::LLVMDialect
inline void registerNonCodegenDialects(mlir::DialectRegistry &registry) { inline void registerNonCodegenDialects(mlir::DialectRegistry &registry) {
registry.insert<FLANG_NONCODEGEN_DIALECT_LIST>(); registry.insert<FLANG_NONCODEGEN_DIALECT_LIST>();
} }
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

flang/include/flang/Tools/CLOptions.inc

//===-- CLOptions.inc -- command line options -------------------*- C++ -*-===// //===-- CLOptions.inc -- command line options -------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// This file defines some shared command-line options that can be used when /// This file defines some shared command-line options that can be used when
/// debugging the test tools. This file must be included into the tool. /// debugging the test tools. This file must be included into the tool.
#include "mlir/Conversion/SCFToStandard/SCFToStandard.h" #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Pass/PassManager.h" #include "mlir/Pass/PassManager.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "mlir/Transforms/Passes.h" #include "mlir/Transforms/Passes.h"
#include "flang/Optimizer/CodeGen/CodeGen.h" #include "flang/Optimizer/CodeGen/CodeGen.h"
#include "flang/Optimizer/Transforms/Passes.h" #include "flang/Optimizer/Transforms/Passes.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#define DisableOption(DOName, DOOption, DODescription) \ #define DisableOption(DOName, DOOption, DODescription) \
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Linesinline void createDefaultFIROptimizerPassPipeline(mlir::PassManager &pm) {
// configuration. Create the inliner pass with tco config. // configuration. Create the inliner pass with tco config.
llvm::StringMap<mlir::OpPassManager> pipelines; llvm::StringMap<mlir::OpPassManager> pipelines;
pm.addPass( pm.addPass(
mlir::createInlinerPass(pipelines, defaultFlangInlinerOptPipeline)); mlir::createInlinerPass(pipelines, defaultFlangInlinerOptPipeline));
pm.addPass(mlir::createCSEPass()); pm.addPass(mlir::createCSEPass());
// convert control flow to CFG form // convert control flow to CFG form
fir::addCfgConversionPass(pm); fir::addCfgConversionPass(pm);
pm.addPass(mlir::createLowerToCFGPass()); pm.addPass(mlir::createConvertSCFToCFPass());
pm.addPass(mlir::createCanonicalizerPass(config)); pm.addPass(mlir::createCanonicalizerPass(config));
} }
#if !defined(FLANG_EXCLUDE_CODEGEN) #if !defined(FLANG_EXCLUDE_CODEGEN)
inline void createDefaultFIRCodeGenPassPipeline(mlir::PassManager &pm) { inline void createDefaultFIRCodeGenPassPipeline(mlir::PassManager &pm) {
pm.addNestedPass<mlir::FuncOp>(fir::createAbstractResultOptPass()); pm.addNestedPass<mlir::FuncOp>(fir::createAbstractResultOptPass());
fir::addCodeGenRewritePass(pm); fir::addCodeGenRewritePass(pm);
Show All 18 Lines

flang/lib/Lower/CMakeLists.txt

Show All 26 Linesadd_flang_library(FortranLower
FIRTransforms FIRTransforms
${dialect_libs} ${dialect_libs}
FortranCommon FortranCommon
FortranParser FortranParser
FortranEvaluate FortranEvaluate
FortranSemantics FortranSemantics
MLIRAffineToStandard MLIRAffineToStandard
MLIRLLVMIR MLIRLLVMIR
MLIRSCFToStandard MLIRSCFToControlFlow
MLIRStandard MLIRStandard
LINK_COMPONENTS LINK_COMPONENTS
Support Support
) )

flang/lib/Optimizer/CodeGen/CodeGen.cpp

Show All 12 Lines
#include "flang/Optimizer/CodeGen/CodeGen.h" #include "flang/Optimizer/CodeGen/CodeGen.h"
#include "CGOps.h" #include "CGOps.h"
#include "PassDetail.h" #include "PassDetail.h"
#include "flang/ISO_Fortran_binding.h" #include "flang/ISO_Fortran_binding.h"
#include "flang/Optimizer/Dialect/FIRAttr.h" #include "flang/Optimizer/Dialect/FIRAttr.h"
#include "flang/Optimizer/Dialect/FIROps.h" #include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Support/TypeCode.h" #include "flang/Optimizer/Support/TypeCode.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Target/LLVMIR/ModuleTranslation.h" #include "mlir/Target/LLVMIR/ModuleTranslation.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
▲ Show 20 Lines • Show All 3,259 Lines • ▼ Show 20 Lines pattern.insert<
SliceOpConversion, StoreOpConversion, StringLitOpConversion, SliceOpConversion, StoreOpConversion, StringLitOpConversion,
SubcOpConversion, UnboxCharOpConversion, UnboxProcOpConversion, SubcOpConversion, UnboxCharOpConversion, UnboxProcOpConversion,
UndefOpConversion, UnreachableOpConversion, XArrayCoorOpConversion, UndefOpConversion, UnreachableOpConversion, XArrayCoorOpConversion,
XEmboxOpConversion, XReboxOpConversion, ZeroOpConversion>( XEmboxOpConversion, XReboxOpConversion, ZeroOpConversion>(
typeConverter); typeConverter);
mlir::populateStdToLLVMConversionPatterns(typeConverter, pattern); mlir::populateStdToLLVMConversionPatterns(typeConverter, pattern);
mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter, mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
pattern); pattern);
mlir::cf::populateControlFlowToLLVMConversionPatterns(typeConverter,
pattern);
mlir::ConversionTarget target{*context}; mlir::ConversionTarget target{*context};
target.addLegalDialect<mlir::LLVM::LLVMDialect>(); target.addLegalDialect<mlir::LLVM::LLVMDialect>();
// required NOPs for applying a full conversion // required NOPs for applying a full conversion
target.addLegalOp<mlir::ModuleOp>(); target.addLegalOp<mlir::ModuleOp>();
// apply the patterns // apply the patterns
if (mlir::failed(mlir::applyFullConversion(getModule(), target, if (mlir::failed(mlir::applyFullConversion(getModule(), target,
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

flang/lib/Optimizer/Transforms/ArrayValueCopy.cpp

//===-- ArrayValueCopy.cpp ------------------------------------------------===// //===-- ArrayValueCopy.cpp ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PassDetail.h" #include "PassDetail.h"
#include "flang/Optimizer/Builder/BoxValue.h" #include "flang/Optimizer/Builder/BoxValue.h"
#include "flang/Optimizer/Builder/FIRBuilder.h" #include "flang/Optimizer/Builder/FIRBuilder.h"
#include "flang/Optimizer/Builder/Factory.h" #include "flang/Optimizer/Builder/Factory.h"
#include "flang/Optimizer/Dialect/FIRDialect.h" #include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Support/FIRContext.h" #include "flang/Optimizer/Support/FIRContext.h"
#include "flang/Optimizer/Transforms/Passes.h" #include "flang/Optimizer/Transforms/Passes.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#define DEBUG_TYPE "flang-array-value-copy" #define DEBUG_TYPE "flang-array-value-copy"
using namespace fir; using namespace fir;
▲ Show 20 Lines • Show All 303 Lines • ▼ Show 20 Lines if (auto ro = mlir::dyn_cast<DoLoopOp>(owner)) {
appendToQueue(update.getResult()); appendToQueue(update.getResult());
} else if (auto update = mlir::dyn_cast<ArrayModifyOp>(owner)) { } else if (auto update = mlir::dyn_cast<ArrayModifyOp>(owner)) {
// Keep track of array value modification and thread the return value // Keep track of array value modification and thread the return value
// uses. // uses.
LLVM_DEBUG(llvm::dbgs() LLVM_DEBUG(llvm::dbgs()
<< "add modify {" << *owner << "} to array value set\n"); << "add modify {" << *owner << "} to array value set\n");
accesses.push_back(owner); accesses.push_back(owner);
appendToQueue(update.getResult(1)); appendToQueue(update.getResult(1));
} else if (auto br = mlir::dyn_cast<mlir::BranchOp>(owner)) { } else if (auto br = mlir::dyn_cast<mlir::cf::BranchOp>(owner)) {
branchOp(br.getDest(), br.getDestOperands()); branchOp(br.getDest(), br.getDestOperands());
} else if (auto br = mlir::dyn_cast<mlir::CondBranchOp>(owner)) { } else if (auto br = mlir::dyn_cast<mlir::cf::CondBranchOp>(owner)) {
branchOp(br.getTrueDest(), br.getTrueOperands()); branchOp(br.getTrueDest(), br.getTrueOperands());
branchOp(br.getFalseDest(), br.getFalseOperands()); branchOp(br.getFalseDest(), br.getFalseOperands());
} else if (mlir::isa<ArrayMergeStoreOp>(owner)) { } else if (mlir::isa<ArrayMergeStoreOp>(owner)) {
// do nothing // do nothing
} else { } else {
llvm::report_fatal_error("array value reached unexpected op"); llvm::report_fatal_error("array value reached unexpected op");
} }
} }
▲ Show 20 Lines • Show All 438 Lines • ▼ Show 20 Lines void runOnOperation() override {
// array accesses are rewritten we can go on phase 2. // array accesses are rewritten we can go on phase 2.
// Phase 2 gets rid of the useless copy-in/copyout operations. The copy-in // Phase 2 gets rid of the useless copy-in/copyout operations. The copy-in
// /copy-out refers the Fortran copy-in/copy-out semantics on statements. // /copy-out refers the Fortran copy-in/copy-out semantics on statements.
mlir::RewritePatternSet patterns1(context); mlir::RewritePatternSet patterns1(context);
patterns1.insert<ArrayFetchConversion>(context, useMap); patterns1.insert<ArrayFetchConversion>(context, useMap);
patterns1.insert<ArrayUpdateConversion>(context, analysis, useMap); patterns1.insert<ArrayUpdateConversion>(context, analysis, useMap);
patterns1.insert<ArrayModifyConversion>(context, analysis, useMap); patterns1.insert<ArrayModifyConversion>(context, analysis, useMap);
mlir::ConversionTarget target(*context); mlir::ConversionTarget target(*context);
target.addLegalDialect<FIROpsDialect, mlir::scf::SCFDialect, target.addLegalDialect<
mlir::arith::ArithmeticDialect, FIROpsDialect, mlir::scf::SCFDialect, mlir::arith::ArithmeticDialect,
mlir::StandardOpsDialect>(); mlir::cf::ControlFlowDialect, mlir::StandardOpsDialect>();
target.addIllegalOp<ArrayFetchOp, ArrayUpdateOp, ArrayModifyOp>(); target.addIllegalOp<ArrayFetchOp, ArrayUpdateOp, ArrayModifyOp>();
// Rewrite the array fetch and array update ops. // Rewrite the array fetch and array update ops.
if (mlir::failed( if (mlir::failed(
mlir::applyPartialConversion(func, target, std::move(patterns1)))) { mlir::applyPartialConversion(func, target, std::move(patterns1)))) {
mlir::emitError(mlir::UnknownLoc::get(context), mlir::emitError(mlir::UnknownLoc::get(context),
"failure in array-value-copy pass, phase 1"); "failure in array-value-copy pass, phase 1");
signalPassFailure(); signalPassFailure();
} }
Show All 18 Lines

flang/lib/Optimizer/Transforms/RewriteLoop.cpp

//===-- RewriteLoop.cpp ---------------------------------------------------===// //===-- RewriteLoop.cpp ---------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PassDetail.h" #include "PassDetail.h"
#include "flang/Optimizer/Dialect/FIRDialect.h" #include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Dialect/FIROps.h" #include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Transforms/Passes.h" #include "flang/Optimizer/Transforms/Passes.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
using namespace fir; using namespace fir;
namespace { namespace {
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines matchAndRewrite(DoLoopOp loop,
} }
llvm::SmallVector<mlir::Value> loopOperands; llvm::SmallVector<mlir::Value> loopOperands;
loopOperands.push_back(low); loopOperands.push_back(low);
auto operands = loop.getIterOperands(); auto operands = loop.getIterOperands();
loopOperands.append(operands.begin(), operands.end()); loopOperands.append(operands.begin(), operands.end());
loopOperands.push_back(iters); loopOperands.push_back(iters);
rewriter.create<mlir::BranchOp>(loc, conditionalBlock, loopOperands); rewriter.create<mlir::cf::BranchOp>(loc, conditionalBlock, loopOperands);
// Last loop block // Last loop block
auto *terminator = lastBlock->getTerminator(); auto *terminator = lastBlock->getTerminator();
rewriter.setInsertionPointToEnd(lastBlock); rewriter.setInsertionPointToEnd(lastBlock);
auto iv = conditionalBlock->getArgument(0); auto iv = conditionalBlock->getArgument(0);
mlir::Value steppedIndex = mlir::Value steppedIndex =
rewriter.create<mlir::arith::AddIOp>(loc, iv, step); rewriter.create<mlir::arith::AddIOp>(loc, iv, step);
assert(steppedIndex && "must be a Value"); assert(steppedIndex && "must be a Value");
auto lastArg = conditionalBlock->getNumArguments() - 1; auto lastArg = conditionalBlock->getNumArguments() - 1;
auto itersLeft = conditionalBlock->getArgument(lastArg); auto itersLeft = conditionalBlock->getArgument(lastArg);
auto one = rewriter.create<mlir::arith::ConstantIndexOp>(loc, 1); auto one = rewriter.create<mlir::arith::ConstantIndexOp>(loc, 1);
mlir::Value itersMinusOne = mlir::Value itersMinusOne =
rewriter.create<mlir::arith::SubIOp>(loc, itersLeft, one); rewriter.create<mlir::arith::SubIOp>(loc, itersLeft, one);
llvm::SmallVector<mlir::Value> loopCarried; llvm::SmallVector<mlir::Value> loopCarried;
loopCarried.push_back(steppedIndex); loopCarried.push_back(steppedIndex);
auto begin = loop.finalValue() ? std::next(terminator->operand_begin()) auto begin = loop.finalValue() ? std::next(terminator->operand_begin())
: terminator->operand_begin(); : terminator->operand_begin();
loopCarried.append(begin, terminator->operand_end()); loopCarried.append(begin, terminator->operand_end());
loopCarried.push_back(itersMinusOne); loopCarried.push_back(itersMinusOne);
rewriter.create<mlir::BranchOp>(loc, conditionalBlock, loopCarried); rewriter.create<mlir::cf::BranchOp>(loc, conditionalBlock, loopCarried);
rewriter.eraseOp(terminator); rewriter.eraseOp(terminator);
// Conditional block // Conditional block
rewriter.setInsertionPointToEnd(conditionalBlock); rewriter.setInsertionPointToEnd(conditionalBlock);
auto zero = rewriter.create<mlir::arith::ConstantIndexOp>(loc, 0); auto zero = rewriter.create<mlir::arith::ConstantIndexOp>(loc, 0);
auto comparison = rewriter.create<mlir::arith::CmpIOp>( auto comparison = rewriter.create<mlir::arith::CmpIOp>(
loc, arith::CmpIPredicate::sgt, itersLeft, zero); loc, arith::CmpIPredicate::sgt, itersLeft, zero);
rewriter.create<mlir::CondBranchOp>(loc, comparison, firstBlock, rewriter.create<mlir::cf::CondBranchOp>(
llvm::ArrayRef<mlir::Value>(), endBlock, loc, comparison, firstBlock, llvm::ArrayRef<mlir::Value>(), endBlock,
llvm::ArrayRef<mlir::Value>()); llvm::ArrayRef<mlir::Value>());
// The result of the loop operation is the values of the condition block // The result of the loop operation is the values of the condition block
// arguments except the induction variable on the last iteration. // arguments except the induction variable on the last iteration.
auto args = loop.finalValue() auto args = loop.finalValue()
? conditionalBlock->getArguments() ? conditionalBlock->getArguments()
: conditionalBlock->getArguments().drop_front(); : conditionalBlock->getArguments().drop_front();
rewriter.replaceOp(loop, args.drop_back()); rewriter.replaceOp(loop, args.drop_back());
return success(); return success();
Show All 22 Lines matchAndRewrite(IfOp ifOp, mlir::PatternRewriter &rewriter) const override {
auto opPosition = rewriter.getInsertionPoint(); auto opPosition = rewriter.getInsertionPoint();
auto *remainingOpsBlock = rewriter.splitBlock(condBlock, opPosition); auto *remainingOpsBlock = rewriter.splitBlock(condBlock, opPosition);
mlir::Block *continueBlock; mlir::Block *continueBlock;
if (ifOp.getNumResults() == 0) { if (ifOp.getNumResults() == 0) {
continueBlock = remainingOpsBlock; continueBlock = remainingOpsBlock;
} else { } else {
continueBlock = continueBlock =
rewriter.createBlock(remainingOpsBlock, ifOp.getResultTypes()); rewriter.createBlock(remainingOpsBlock, ifOp.getResultTypes());
rewriter.create<mlir::BranchOp>(loc, remainingOpsBlock); rewriter.create<mlir::cf::BranchOp>(loc, remainingOpsBlock);
} }
// Move blocks from the "then" region to the region containing 'fir.if', // Move blocks from the "then" region to the region containing 'fir.if',
// place it before the continuation block, and branch to it. // place it before the continuation block, and branch to it.
auto &ifOpRegion = ifOp.thenRegion(); auto &ifOpRegion = ifOp.thenRegion();
auto *ifOpBlock = &ifOpRegion.front(); auto *ifOpBlock = &ifOpRegion.front();
auto *ifOpTerminator = ifOpRegion.back().getTerminator(); auto *ifOpTerminator = ifOpRegion.back().getTerminator();
auto ifOpTerminatorOperands = ifOpTerminator->getOperands(); auto ifOpTerminatorOperands = ifOpTerminator->getOperands();
rewriter.setInsertionPointToEnd(&ifOpRegion.back()); rewriter.setInsertionPointToEnd(&ifOpRegion.back());
rewriter.create<mlir::BranchOp>(loc, continueBlock, ifOpTerminatorOperands); rewriter.create<mlir::cf::BranchOp>(loc, continueBlock,
ifOpTerminatorOperands);
rewriter.eraseOp(ifOpTerminator); rewriter.eraseOp(ifOpTerminator);
rewriter.inlineRegionBefore(ifOpRegion, continueBlock); rewriter.inlineRegionBefore(ifOpRegion, continueBlock);
// Move blocks from the "else" region (if present) to the region containing // Move blocks from the "else" region (if present) to the region containing
// 'fir.if', place it before the continuation block and branch to it. It // 'fir.if', place it before the continuation block and branch to it. It
// will be placed after the "then" regions. // will be placed after the "then" regions.
auto *otherwiseBlock = continueBlock; auto *otherwiseBlock = continueBlock;
auto &otherwiseRegion = ifOp.elseRegion(); auto &otherwiseRegion = ifOp.elseRegion();
if (!otherwiseRegion.empty()) { if (!otherwiseRegion.empty()) {
otherwiseBlock = &otherwiseRegion.front(); otherwiseBlock = &otherwiseRegion.front();
auto *otherwiseTerm = otherwiseRegion.back().getTerminator(); auto *otherwiseTerm = otherwiseRegion.back().getTerminator();
auto otherwiseTermOperands = otherwiseTerm->getOperands(); auto otherwiseTermOperands = otherwiseTerm->getOperands();
rewriter.setInsertionPointToEnd(&otherwiseRegion.back()); rewriter.setInsertionPointToEnd(&otherwiseRegion.back());
rewriter.create<mlir::BranchOp>(loc, continueBlock, rewriter.create<mlir::cf::BranchOp>(loc, continueBlock,
otherwiseTermOperands); otherwiseTermOperands);
rewriter.eraseOp(otherwiseTerm); rewriter.eraseOp(otherwiseTerm);
rewriter.inlineRegionBefore(otherwiseRegion, continueBlock); rewriter.inlineRegionBefore(otherwiseRegion, continueBlock);
} }
rewriter.setInsertionPointToEnd(condBlock); rewriter.setInsertionPointToEnd(condBlock);
rewriter.create<mlir::CondBranchOp>( rewriter.create<mlir::cf::CondBranchOp>(
loc, ifOp.condition(), ifOpBlock, llvm::ArrayRef<mlir::Value>(), loc, ifOp.condition(), ifOpBlock, llvm::ArrayRef<mlir::Value>(),
otherwiseBlock, llvm::ArrayRef<mlir::Value>()); otherwiseBlock, llvm::ArrayRef<mlir::Value>());
rewriter.replaceOp(ifOp, continueBlock->getArguments()); rewriter.replaceOp(ifOp, continueBlock->getArguments());
return success(); return success();
} }
}; };
/// Convert `fir.iter_while` to control-flow. /// Convert `fir.iter_while` to control-flow.
Show All 38 Lines matchAndRewrite(fir::IterWhileOp whileOp,
mlir::Value stepped = rewriter.create<mlir::arith::AddIOp>(loc, iv, step); mlir::Value stepped = rewriter.create<mlir::arith::AddIOp>(loc, iv, step);
assert(stepped && "must be a Value"); assert(stepped && "must be a Value");
llvm::SmallVector<mlir::Value> loopCarried; llvm::SmallVector<mlir::Value> loopCarried;
loopCarried.push_back(stepped); loopCarried.push_back(stepped);
auto begin = whileOp.finalValue() ? std::next(terminator->operand_begin()) auto begin = whileOp.finalValue() ? std::next(terminator->operand_begin())
: terminator->operand_begin(); : terminator->operand_begin();
loopCarried.append(begin, terminator->operand_end()); loopCarried.append(begin, terminator->operand_end());
rewriter.create<mlir::BranchOp>(loc, conditionBlock, loopCarried); rewriter.create<mlir::cf::BranchOp>(loc, conditionBlock, loopCarried);
rewriter.eraseOp(terminator); rewriter.eraseOp(terminator);
// Compute loop bounds before branching to the condition. // Compute loop bounds before branching to the condition.
rewriter.setInsertionPointToEnd(initBlock); rewriter.setInsertionPointToEnd(initBlock);
auto lowerBound = whileOp.lowerBound(); auto lowerBound = whileOp.lowerBound();
auto upperBound = whileOp.upperBound(); auto upperBound = whileOp.upperBound();
assert(lowerBound && upperBound && "must be a Value"); assert(lowerBound && upperBound && "must be a Value");
// The initial values of loop-carried values is obtained from the operands // The initial values of loop-carried values is obtained from the operands
// of the loop operation. // of the loop operation.
llvm::SmallVector<mlir::Value> destOperands; llvm::SmallVector<mlir::Value> destOperands;
destOperands.push_back(lowerBound); destOperands.push_back(lowerBound);
auto iterOperands = whileOp.getIterOperands(); auto iterOperands = whileOp.getIterOperands();
destOperands.append(iterOperands.begin(), iterOperands.end()); destOperands.append(iterOperands.begin(), iterOperands.end());
rewriter.create<mlir::BranchOp>(loc, conditionBlock, destOperands); rewriter.create<mlir::cf::BranchOp>(loc, conditionBlock, destOperands);
// With the body block done, we can fill in the condition block. // With the body block done, we can fill in the condition block.
rewriter.setInsertionPointToEnd(conditionBlock); rewriter.setInsertionPointToEnd(conditionBlock);
// The comparison depends on the sign of the step value. We fully expect // The comparison depends on the sign of the step value. We fully expect
// this expression to be folded by the optimizer or LLVM. This expression // this expression to be folded by the optimizer or LLVM. This expression
// is written this way so that `step == 0` always returns `false`. // is written this way so that `step == 0` always returns `false`.
auto zero = rewriter.create<mlir::arith::ConstantIndexOp>(loc, 0); auto zero = rewriter.create<mlir::arith::ConstantIndexOp>(loc, 0);
auto compl0 = rewriter.create<mlir::arith::CmpIOp>( auto compl0 = rewriter.create<mlir::arith::CmpIOp>(
loc, arith::CmpIPredicate::slt, zero, step); loc, arith::CmpIPredicate::slt, zero, step);
auto compl1 = rewriter.create<mlir::arith::CmpIOp>( auto compl1 = rewriter.create<mlir::arith::CmpIOp>(
loc, arith::CmpIPredicate::sle, iv, upperBound); loc, arith::CmpIPredicate::sle, iv, upperBound);
auto compl2 = rewriter.create<mlir::arith::CmpIOp>( auto compl2 = rewriter.create<mlir::arith::CmpIOp>(
loc, arith::CmpIPredicate::slt, step, zero); loc, arith::CmpIPredicate::slt, step, zero);
auto compl3 = rewriter.create<mlir::arith::CmpIOp>( auto compl3 = rewriter.create<mlir::arith::CmpIOp>(
loc, arith::CmpIPredicate::sle, upperBound, iv); loc, arith::CmpIPredicate::sle, upperBound, iv);
auto cmp0 = rewriter.create<mlir::arith::AndIOp>(loc, compl0, compl1); auto cmp0 = rewriter.create<mlir::arith::AndIOp>(loc, compl0, compl1);
auto cmp1 = rewriter.create<mlir::arith::AndIOp>(loc, compl2, compl3); auto cmp1 = rewriter.create<mlir::arith::AndIOp>(loc, compl2, compl3);
auto cmp2 = rewriter.create<mlir::arith::OrIOp>(loc, cmp0, cmp1); auto cmp2 = rewriter.create<mlir::arith::OrIOp>(loc, cmp0, cmp1);
// Remember to AND in the early-exit bool. // Remember to AND in the early-exit bool.
auto comparison = auto comparison =
rewriter.create<mlir::arith::AndIOp>(loc, iterateVar, cmp2); rewriter.create<mlir::arith::AndIOp>(loc, iterateVar, cmp2);
rewriter.create<mlir::CondBranchOp>(loc, comparison, firstBodyBlock, rewriter.create<mlir::cf::CondBranchOp>(
llvm::ArrayRef<mlir::Value>(), endBlock, loc, comparison, firstBodyBlock, llvm::ArrayRef<mlir::Value>(),
llvm::ArrayRef<mlir::Value>()); endBlock, llvm::ArrayRef<mlir::Value>());
// The result of the loop operation is the values of the condition block // The result of the loop operation is the values of the condition block
// arguments except the induction variable on the last iteration. // arguments except the induction variable on the last iteration.
auto args = whileOp.finalValue() auto args = whileOp.finalValue()
? conditionBlock->getArguments() ? conditionBlock->getArguments()
: conditionBlock->getArguments().drop_front(); : conditionBlock->getArguments().drop_front();
rewriter.replaceOp(whileOp, args); rewriter.replaceOp(whileOp, args);
return success(); return success();
} }
}; };
/// Convert FIR structured control flow ops to CFG ops. /// Convert FIR structured control flow ops to CFG ops.
class CfgConversion : public CFGConversionBase<CfgConversion> { class CfgConversion : public CFGConversionBase<CfgConversion> {
public: public:
void runOnOperation() override { void runOnOperation() override {
auto *context = &getContext(); auto *context = &getContext();
mlir::RewritePatternSet patterns(context); mlir::RewritePatternSet patterns(context);
patterns.insert<CfgLoopConv, CfgIfConv, CfgIterWhileConv>( patterns.insert<CfgLoopConv, CfgIfConv, CfgIterWhileConv>(
context, forceLoopToExecuteOnce); context, forceLoopToExecuteOnce);
mlir::ConversionTarget target(*context); mlir::ConversionTarget target(*context);
target.addLegalDialect<mlir::AffineDialect, FIROpsDialect, target.addLegalDialect<mlir::AffineDialect, mlir::cf::ControlFlowDialect,
mlir::StandardOpsDialect>(); FIROpsDialect, mlir::StandardOpsDialect>();
// apply the patterns // apply the patterns
target.addIllegalOp<ResultOp, DoLoopOp, IfOp, IterWhileOp>(); target.addIllegalOp<ResultOp, DoLoopOp, IfOp, IterWhileOp>();
target.markUnknownOpDynamicallyLegal([](Operation *) { return true; }); target.markUnknownOpDynamicallyLegal([](Operation *) { return true; });
if (mlir::failed(mlir::applyPartialConversion(getOperation(), target, if (mlir::failed(mlir::applyPartialConversion(getOperation(), target,
std::move(patterns)))) { std::move(patterns)))) {
mlir::emitError(mlir::UnknownLoc::get(context), mlir::emitError(mlir::UnknownLoc::get(context),
"error in converting to CFG\n"); "error in converting to CFG\n");
Show All 12 Lines

flang/test/Fir/Todo/select_case_with_character.fir

// RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
// Test `fir.select_case` conversion to llvm with character type. // Test `fir.select_case` conversion to llvm with character type.
// Not implemented yet. // Not implemented yet.
func @select_case_charachter(%arg0: !fir.char<2, 10>, %arg1: !fir.char<2, 10>, %arg2: !fir.char<2, 10>) { func @select_case_charachter(%arg0: !fir.char<2, 10>, %arg1: !fir.char<2, 10>, %arg2: !fir.char<2, 10>) {
// CHECK: not yet implemented fir.select_case codegen with character type // CHECK: not yet implemented fir.select_case codegen with character type
fir.select_case %arg0 : !fir.char<2, 10> [#fir.point, %arg1, ^bb1, fir.select_case %arg0 : !fir.char<2, 10> [#fir.point, %arg1, ^bb1,
#fir.point, %arg2, ^bb2, #fir.point, %arg2, ^bb2,
unit, ^bb3] unit, ^bb3]
^bb1: ^bb1:
%c1_i32 = arith.constant 1 : i32 %c1_i32 = arith.constant 1 : i32
br ^bb3 cf.br ^bb3
^bb2: ^bb2:
%c2_i32 = arith.constant 2 : i32 %c2_i32 = arith.constant 2 : i32
br ^bb3 cf.br ^bb3
^bb3: ^bb3:
return return
} }

flang/test/Fir/convert-to-llvm.fir

Show First 20 Lines • Show All 1,169 Lines • ▼ Show 20 Lines fir.select_case %2 : i32 [#fir.upper, %c1_i32, ^bb1,
#fir.interval, %c4_i32, %c5_i32, ^bb4, #fir.interval, %c4_i32, %c5_i32, ^bb4,
#fir.point, %c7_i32, ^bb5, #fir.point, %c7_i32, ^bb5,
#fir.interval, %c8_i32, %c15_i32, ^bb5, #fir.interval, %c8_i32, %c15_i32, ^bb5,
#fir.lower, %c21_i32, ^bb5, #fir.lower, %c21_i32, ^bb5,
unit, ^bb3] unit, ^bb3]
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%c1_i32_0 = arith.constant 1 : i32 %c1_i32_0 = arith.constant 1 : i32
fir.store %c1_i32_0 to %arg0 : !fir.ref<i32> fir.store %c1_i32_0 to %arg0 : !fir.ref<i32>
br ^bb6 cf.br ^bb6
^bb2: // pred: ^bb0 ^bb2: // pred: ^bb0
%c2_i32_1 = arith.constant 2 : i32 %c2_i32_1 = arith.constant 2 : i32
fir.store %c2_i32_1 to %arg0 : !fir.ref<i32> fir.store %c2_i32_1 to %arg0 : !fir.ref<i32>
br ^bb6 cf.br ^bb6
^bb3: // pred: ^bb0 ^bb3: // pred: ^bb0
%c0_i32 = arith.constant 0 : i32 %c0_i32 = arith.constant 0 : i32
fir.store %c0_i32 to %arg0 : !fir.ref<i32> fir.store %c0_i32 to %arg0 : !fir.ref<i32>
br ^bb6 cf.br ^bb6
^bb4: // pred: ^bb0 ^bb4: // pred: ^bb0
%c4_i32_2 = arith.constant 4 : i32 %c4_i32_2 = arith.constant 4 : i32
fir.store %c4_i32_2 to %arg0 : !fir.ref<i32> fir.store %c4_i32_2 to %arg0 : !fir.ref<i32>
br ^bb6 cf.br ^bb6
^bb5: // 3 preds: ^bb0, ^bb0, ^bb0 ^bb5: // 3 preds: ^bb0, ^bb0, ^bb0
%c7_i32_3 = arith.constant 7 : i32 %c7_i32_3 = arith.constant 7 : i32
fir.store %c7_i32_3 to %arg0 : !fir.ref<i32> fir.store %c7_i32_3 to %arg0 : !fir.ref<i32>
br ^bb6 cf.br ^bb6
^bb6: // 5 preds: ^bb1, ^bb2, ^bb3, ^bb4, ^bb5 ^bb6: // 5 preds: ^bb1, ^bb2, ^bb3, ^bb4, ^bb5
%3 = fir.load %arg0 : !fir.ref<i32> %3 = fir.load %arg0 : !fir.ref<i32>
return %3 : i32 return %3 : i32
} }
// CHECK-LABEL: llvm.func @select_case_integer( // CHECK-LABEL: llvm.func @select_case_integer(
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr<i32>) -> i32 { // CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr<i32>) -> i32 {
// CHECK: %[[SELECT_VALUE:.*]] = llvm.load %[[ARG0]] : !llvm.ptr<i32> // CHECK: %[[SELECT_VALUE:.*]] = llvm.load %[[ARG0]] : !llvm.ptr<i32>
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Linesfunc @select_case_logical(%arg0: !fir.ref<!fir.logical<4>>) {
%2 = fir.convert %1 : (!fir.logical<4>) -> i1 %2 = fir.convert %1 : (!fir.logical<4>) -> i1
%false = arith.constant false %false = arith.constant false
%true = arith.constant true %true = arith.constant true
fir.select_case %2 : i1 [#fir.point, %false, ^bb1, fir.select_case %2 : i1 [#fir.point, %false, ^bb1,
#fir.point, %true, ^bb2, #fir.point, %true, ^bb2,
unit, ^bb3] unit, ^bb3]
^bb1: ^bb1:
%c1_i32 = arith.constant 1 : i32 %c1_i32 = arith.constant 1 : i32
br ^bb3 cf.br ^bb3
^bb2: ^bb2:
%c2_i32 = arith.constant 2 : i32 %c2_i32 = arith.constant 2 : i32
br ^bb3 cf.br ^bb3
^bb3: ^bb3:
return return
} }
// CHECK-LABEL: llvm.func @select_case_logical( // CHECK-LABEL: llvm.func @select_case_logical(
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr<i32> // CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr<i32>
// CHECK: %[[LOAD_ARG0:.*]] = llvm.load %[[ARG0]] : !llvm.ptr<i32> // CHECK: %[[LOAD_ARG0:.*]] = llvm.load %[[ARG0]] : !llvm.ptr<i32>
// CHECK: %[[SELECT_VALUE:.*]] = llvm.trunc %[[LOAD_ARG0]] : i32 to i1 // CHECK: %[[SELECT_VALUE:.*]] = llvm.trunc %[[LOAD_ARG0]] : i32 to i1
▲ Show 20 Lines • Show All 1,288 Lines • Show Last 20 Lines

flang/test/Fir/memref-data-flow.fir

// RUN: fir-opt --split-input-file --fir-memref-dataflow-opt %s | FileCheck %s // RUN: fir-opt --split-input-file --fir-memref-dataflow-opt %s | FileCheck %s
// Test that all load-store chains are removed // Test that all load-store chains are removed
func @load_store_chain_removal(%arg0: !fir.ref<!fir.array<60xi32>>, %arg1: !fir.ref<!fir.array<60xi32>>, %arg2: !fir.ref<!fir.array<60xi32>>) { func @load_store_chain_removal(%arg0: !fir.ref<!fir.array<60xi32>>, %arg1: !fir.ref<!fir.array<60xi32>>, %arg2: !fir.ref<!fir.array<60xi32>>) {
%c1_i64 = arith.constant 1 : i64 %c1_i64 = arith.constant 1 : i64
%c60 = arith.constant 60 : index %c60 = arith.constant 60 : index
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFf1dcEi"} %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFf1dcEi"}
%1 = fir.alloca !fir.array<60xi32> {bindc_name = "t1", uniq_name = "_QFf1dcEt1"} %1 = fir.alloca !fir.array<60xi32> {bindc_name = "t1", uniq_name = "_QFf1dcEt1"}
br ^bb1(%c1, %c60 : index, index) cf.br ^bb1(%c1, %c60 : index, index)
^bb1(%2: index, %3: index): // 2 preds: ^bb0, ^bb2 ^bb1(%2: index, %3: index): // 2 preds: ^bb0, ^bb2
%4 = arith.cmpi sgt, %3, %c0 : index %4 = arith.cmpi sgt, %3, %c0 : index
cond_br %4, ^bb2, ^bb3 cf.cond_br %4, ^bb2, ^bb3
^bb2: // pred: ^bb1 ^bb2: // pred: ^bb1
%5 = fir.convert %2 : (index) -> i32 %5 = fir.convert %2 : (index) -> i32
fir.store %5 to %0 : !fir.ref<i32> fir.store %5 to %0 : !fir.ref<i32>
%6 = fir.load %0 : !fir.ref<i32> %6 = fir.load %0 : !fir.ref<i32>
%7 = fir.convert %6 : (i32) -> i64 %7 = fir.convert %6 : (i32) -> i64
%8 = arith.subi %7, %c1_i64 : i64 %8 = arith.subi %7, %c1_i64 : i64
%9 = fir.coordinate_of %arg0, %8 : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32> %9 = fir.coordinate_of %arg0, %8 : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
%10 = fir.load %9 : !fir.ref<i32> %10 = fir.load %9 : !fir.ref<i32>
%11 = arith.addi %10, %10 : i32 %11 = arith.addi %10, %10 : i32
%12 = fir.coordinate_of %1, %8 : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32> %12 = fir.coordinate_of %1, %8 : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
fir.store %11 to %12 : !fir.ref<i32> fir.store %11 to %12 : !fir.ref<i32>
%13 = arith.addi %2, %c1 : index %13 = arith.addi %2, %c1 : index
%14 = arith.subi %3, %c1 : index %14 = arith.subi %3, %c1 : index
br ^bb1(%13, %14 : index, index) cf.br ^bb1(%13, %14 : index, index)
^bb3: // pred: ^bb1 ^bb3: // pred: ^bb1
%15 = fir.convert %2 : (index) -> i32 %15 = fir.convert %2 : (index) -> i32
fir.store %15 to %0 : !fir.ref<i32> fir.store %15 to %0 : !fir.ref<i32>
br ^bb4(%c1, %c60 : index, index) cf.br ^bb4(%c1, %c60 : index, index)
^bb4(%16: index, %17: index): // 2 preds: ^bb3, ^bb5 ^bb4(%16: index, %17: index): // 2 preds: ^bb3, ^bb5
%18 = arith.cmpi sgt, %17, %c0 : index %18 = arith.cmpi sgt, %17, %c0 : index
cond_br %18, ^bb5, ^bb6 cf.cond_br %18, ^bb5, ^bb6
^bb5: // pred: ^bb4 ^bb5: // pred: ^bb4
%19 = fir.convert %16 : (index) -> i32 %19 = fir.convert %16 : (index) -> i32
fir.store %19 to %0 : !fir.ref<i32> fir.store %19 to %0 : !fir.ref<i32>
%20 = fir.load %0 : !fir.ref<i32> %20 = fir.load %0 : !fir.ref<i32>
%21 = fir.convert %20 : (i32) -> i64 %21 = fir.convert %20 : (i32) -> i64
%22 = arith.subi %21, %c1_i64 : i64 %22 = arith.subi %21, %c1_i64 : i64
%23 = fir.coordinate_of %1, %22 : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32> %23 = fir.coordinate_of %1, %22 : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
%24 = fir.load %23 : !fir.ref<i32> %24 = fir.load %23 : !fir.ref<i32>
%25 = fir.coordinate_of %arg1, %22 : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32> %25 = fir.coordinate_of %arg1, %22 : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
%26 = fir.load %25 : !fir.ref<i32> %26 = fir.load %25 : !fir.ref<i32>
%27 = arith.muli %24, %26 : i32 %27 = arith.muli %24, %26 : i32
%28 = fir.coordinate_of %arg2, %22 : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32> %28 = fir.coordinate_of %arg2, %22 : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
fir.store %27 to %28 : !fir.ref<i32> fir.store %27 to %28 : !fir.ref<i32>
%29 = arith.addi %16, %c1 : index %29 = arith.addi %16, %c1 : index
%30 = arith.subi %17, %c1 : index %30 = arith.subi %17, %c1 : index
br ^bb4(%29, %30 : index, index) cf.br ^bb4(%29, %30 : index, index)
^bb6: // pred: ^bb4 ^bb6: // pred: ^bb4
%31 = fir.convert %16 : (index) -> i32 %31 = fir.convert %16 : (index) -> i32
fir.store %31 to %0 : !fir.ref<i32> fir.store %31 to %0 : !fir.ref<i32>
return return
} }
// CHECK-LABEL: func @load_store_chain_removal // CHECK-LABEL: func @load_store_chain_removal
// CHECK-LABEL: ^bb1 // CHECK-LABEL: ^bb1
Show All 19 Lines

flang/tools/bbc/CMakeLists.txt

add_flang_tool(bbc bbc.cpp add_flang_tool(bbc bbc.cpp
DEPENDS DEPENDS
FIROptCodeGenPassIncGen FIROptCodeGenPassIncGen
) )
llvm_update_compile_flags(bbc) llvm_update_compile_flags(bbc)
get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS) get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
target_link_libraries(bbc PRIVATE target_link_libraries(bbc PRIVATE
FIRDialect FIRDialect
FIRSupport FIRSupport
FIRTransforms FIRTransforms
FIRBuilder FIRBuilder
${dialect_libs} ${dialect_libs}
MLIRAffineToStandard MLIRAffineToStandard
MLIRSCFToStandard MLIRSCFToControlFlow
FortranCommon FortranCommon
FortranParser FortranParser
FortranEvaluate FortranEvaluate
FortranSemantics FortranSemantics
FortranLower FortranLower
) )

flang/tools/bbc/bbc.cpp

Show All 32 Lines
#include "flang/Parser/parsing.h" #include "flang/Parser/parsing.h"
#include "flang/Parser/provenance.h" #include "flang/Parser/provenance.h"
#include "flang/Parser/unparse.h" #include "flang/Parser/unparse.h"
#include "flang/Semantics/expression.h" #include "flang/Semantics/expression.h"
#include "flang/Semantics/runtime-type-info.h" #include "flang/Semantics/runtime-type-info.h"
#include "flang/Semantics/semantics.h" #include "flang/Semantics/semantics.h"
#include "flang/Semantics/unparse-with-symbols.h" #include "flang/Semantics/unparse-with-symbols.h"
#include "flang/Version.inc" #include "flang/Version.inc"
#include "mlir/Conversion/SCFToStandard/SCFToStandard.h"
#include "mlir/IR/AsmState.h" #include "mlir/IR/AsmState.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/MLIRContext.h" #include "mlir/IR/MLIRContext.h"
#include "mlir/Parser.h" #include "mlir/Parser.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Pass/PassManager.h" #include "mlir/Pass/PassManager.h"
#include "mlir/Pass/PassRegistry.h" #include "mlir/Pass/PassRegistry.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
▲ Show 20 Lines • Show All 204 Lines • Show Last 20 Lines

flang/tools/fir-opt/CMakeLists.txt

Show All 12 Linestarget_link_libraries(fir-opt PRIVATE
# "registerFIRPasses()" # "registerFIRPasses()"
MLIRIR MLIRIR
MLIRLLVMIR MLIRLLVMIR
MLIRPass MLIRPass
MLIRStandardToLLVM MLIRStandardToLLVM
MLIRTransforms MLIRTransforms
MLIRAffineToStandard MLIRAffineToStandard
MLIRAnalysis MLIRAnalysis
MLIRSCFToStandard MLIRSCFToControlFlow
MLIRParser MLIRParser
MLIRStandardToLLVM MLIRStandardToLLVM
MLIRSupport MLIRSupport
MLIRVectorToLLVM MLIRVectorToLLVM
MLIROptLib MLIROptLib
) )

flang/tools/tco/CMakeLists.txt

Show All 11 Linestarget_link_libraries(tco PRIVATE
MLIRLLVMIR MLIRLLVMIR
MLIRLLVMToLLVMIRTranslation MLIRLLVMToLLVMIRTranslation
MLIRTargetLLVMIRExport MLIRTargetLLVMIRExport
MLIRPass MLIRPass
MLIRStandardToLLVM MLIRStandardToLLVM
MLIRTransforms MLIRTransforms
MLIRAffineToStandard MLIRAffineToStandard
MLIRAnalysis MLIRAnalysis
MLIRSCFToStandard MLIRSCFToControlFlow
MLIRParser MLIRParser
MLIRStandardToLLVM MLIRStandardToLLVM
MLIRSupport MLIRSupport
MLIRVectorToLLVM MLIRVectorToLLVM
) )

flang/tools/tco/tco.cpp

Show All 11 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "flang/Optimizer/CodeGen/CodeGen.h" #include "flang/Optimizer/CodeGen/CodeGen.h"
#include "flang/Optimizer/Support/FIRContext.h" #include "flang/Optimizer/Support/FIRContext.h"
#include "flang/Optimizer/Support/InitFIR.h" #include "flang/Optimizer/Support/InitFIR.h"
#include "flang/Optimizer/Support/InternalNames.h" #include "flang/Optimizer/Support/InternalNames.h"
#include "flang/Optimizer/Support/KindMapping.h" #include "flang/Optimizer/Support/KindMapping.h"
#include "flang/Optimizer/Transforms/Passes.h" #include "flang/Optimizer/Transforms/Passes.h"
#include "mlir/Conversion/SCFToStandard/SCFToStandard.h"
#include "mlir/IR/AsmState.h" #include "mlir/IR/AsmState.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/MLIRContext.h" #include "mlir/IR/MLIRContext.h"
#include "mlir/Parser.h" #include "mlir/Parser.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Pass/PassManager.h" #include "mlir/Pass/PassManager.h"
#include "mlir/Transforms/Passes.h" #include "mlir/Transforms/Passes.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

mlir/benchmark/python/common.py

Show All 20 Linesdef setup_passes(mlir_module):
) )
pipeline = ( pipeline = (
f"builtin.func" f"builtin.func"
f"(linalg-generalize-named-ops,linalg-fuse-elementwise-ops)," f"(linalg-generalize-named-ops,linalg-fuse-elementwise-ops),"
f"sparsification{{{opt}}}," f"sparsification{{{opt}}},"
f"sparse-tensor-conversion," f"sparse-tensor-conversion,"
f"builtin.func" f"builtin.func"
f"(linalg-bufferize,convert-linalg-to-loops,convert-vector-to-scf)," f"(linalg-bufferize,convert-linalg-to-loops,convert-vector-to-scf),"
f"convert-scf-to-std," f"convert-scf-to-cf,"
f"func-bufferize," f"func-bufferize,"
f"arith-bufferize," f"arith-bufferize,"
f"builtin.func(tensor-bufferize,finalizing-bufferize)," f"builtin.func(tensor-bufferize,finalizing-bufferize),"
f"convert-vector-to-llvm" f"convert-vector-to-llvm"
f"{{reassociate-fp-reductions=1 enable-index-optimizations=1}}," f"{{reassociate-fp-reductions=1 enable-index-optimizations=1}},"
f"lower-affine," f"lower-affine,"
f"convert-memref-to-llvm," f"convert-memref-to-llvm,"
f"convert-std-to-llvm," f"convert-std-to-llvm,"
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

mlir/docs/BufferDeallocationInternals.md

Show All 35 Lines
is allowed (fill buffer step by step in a loop e.g.). This means, all buffer is allowed (fill buffer step by step in a loop e.g.). This means, all buffer
writes needs to dominate all buffer reads. writes needs to dominate all buffer reads.
Example for breaking the invariant: Example for breaking the invariant:
```mlir ```mlir
func @condBranch(%arg0: i1, %arg1: memref<2xf32>) { func @condBranch(%arg0: i1, %arg1: memref<2xf32>) {
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3() cf.br ^bb3()
^bb2: ^bb2:
partial_write(%0, %0) partial_write(%0, %0)
br ^bb3() cf.br ^bb3()
^bb3(): ^bb3():
test.copy(%0, %arg1) : (memref<2xf32>, memref<2xf32>) -> () test.copy(%0, %arg1) : (memref<2xf32>, memref<2xf32>) -> ()
return return
} }
``` ```
The maintenance of the SSA like properties is only needed in the bufferization The maintenance of the SSA like properties is only needed in the bufferization
process. Afterwards, for example in optimization processes, the property is no process. Afterwards, for example in optimization processes, the property is no
Show All 11 Lines
tracked internally, and thus, not deallocated automatically. However, tracked internally, and thus, not deallocated automatically. However,
BufferDeallocation is fully compatible with “hybrid” setups in which tracked and BufferDeallocation is fully compatible with “hybrid” setups in which tracked and
untracked allocations are mixed: untracked allocations are mixed:
```mlir ```mlir
func @mixedAllocation(%arg0: i1) { func @mixedAllocation(%arg0: i1) {
%0 = memref.alloca() : memref<2xf32> // aliases: %2 %0 = memref.alloca() : memref<2xf32> // aliases: %2
%1 = memref.alloc() : memref<2xf32> // aliases: %2 %1 = memref.alloc() : memref<2xf32> // aliases: %2
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
use(%0) use(%0)
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb2: ^bb2:
use(%1) use(%1)
br ^bb3(%1 : memref<2xf32>) cf.br ^bb3(%1 : memref<2xf32>)
^bb3(%2: memref<2xf32>): ^bb3(%2: memref<2xf32>):
... ...
} }
``` ```
Example of using a conditional branch with alloc and alloca. BufferDeallocation Example of using a conditional branch with alloc and alloca. BufferDeallocation
can detect and handle the different allocation types that might be intermixed. can detect and handle the different allocation types that might be intermixed.
Show All 32 Lines
The following code snippets shows a conditional branch before running the The following code snippets shows a conditional branch before running the
BufferHoisting pass: BufferHoisting pass:
![branch_example_pre_move](/includes/img/branch_example_pre_move.svg) ![branch_example_pre_move](/includes/img/branch_example_pre_move.svg)
```mlir ```mlir
func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloc() : memref<2xf32> // aliases: %1 %0 = memref.alloc() : memref<2xf32> // aliases: %1
use(%0) use(%0)
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): // %1 could be %0 or %arg1 ^bb3(%1: memref<2xf32>): // %1 could be %0 or %arg1
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) -> () test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) -> ()
return return
} }
``` ```
Applying the BufferHoisting pass on this program results in the following piece Applying the BufferHoisting pass on this program results in the following piece
of code: of code:
![branch_example_post_move](/includes/img/branch_example_post_move.svg) ![branch_example_post_move](/includes/img/branch_example_post_move.svg)
```mlir ```mlir
func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
%0 = memref.alloc() : memref<2xf32> // moved to bb0 %0 = memref.alloc() : memref<2xf32> // moved to bb0
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
use(%0) use(%0)
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) -> () test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) -> ()
return return
} }
``` ```
The alloc is moved from bb2 to the beginning and it is passed as an argument to The alloc is moved from bb2 to the beginning and it is passed as an argument to
bb3. bb3.
The following example demonstrates an allocation using dynamically shaped types. The following example demonstrates an allocation using dynamically shaped types.
Due to the data dependency of the allocation to %0, we cannot move the Due to the data dependency of the allocation to %0, we cannot move the
allocation out of bb2 in this case: allocation out of bb2 in this case:
```mlir ```mlir
func @condBranchDynamicType( func @condBranchDynamicType(
%arg0: i1, %arg0: i1,
%arg1: memref<?xf32>, %arg1: memref<?xf32>,
%arg2: memref<?xf32>, %arg2: memref<?xf32>,
%arg3: index) { %arg3: index) {
cond_br %arg0, ^bb1, ^bb2(%arg3: index) cf.cond_br %arg0, ^bb1, ^bb2(%arg3: index)
^bb1: ^bb1:
br ^bb3(%arg1 : memref<?xf32>) cf.br ^bb3(%arg1 : memref<?xf32>)
^bb2(%0: index): ^bb2(%0: index):
%1 = memref.alloc(%0) : memref<?xf32> // cannot be moved upwards to the data %1 = memref.alloc(%0) : memref<?xf32> // cannot be moved upwards to the data
// dependency to %0 // dependency to %0
use(%1) use(%1)
br ^bb3(%1 : memref<?xf32>) cf.br ^bb3(%1 : memref<?xf32>)
^bb3(%2: memref<?xf32>): ^bb3(%2: memref<?xf32>):
test.copy(%2, %arg2) : (memref<?xf32>, memref<?xf32>) -> () test.copy(%2, %arg2) : (memref<?xf32>, memref<?xf32>) -> ()
return return
} }
``` ```
## Introduction of Clones ## Introduction of Clones
In order to guarantee that all allocated buffers are freed properly, we have to In order to guarantee that all allocated buffers are freed properly, we have to
pay attention to the control flow and all potential aliases a buffer allocation pay attention to the control flow and all potential aliases a buffer allocation
can have. Since not all allocations can be safely freed with respect to their can have. Since not all allocations can be safely freed with respect to their
aliases (see the following code snippet), it is often required to introduce aliases (see the following code snippet), it is often required to introduce
copies to eliminate them. Consider the following example in which the copies to eliminate them. Consider the following example in which the
allocations have already been placed: allocations have already been placed:
```mlir ```mlir
func @branch(%arg0: i1) { func @branch(%arg0: i1) {
%0 = memref.alloc() : memref<2xf32> // aliases: %2 %0 = memref.alloc() : memref<2xf32> // aliases: %2
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
%1 = memref.alloc() : memref<2xf32> // resides here for demonstration purposes %1 = memref.alloc() : memref<2xf32> // resides here for demonstration purposes
// aliases: %2 // aliases: %2
br ^bb3(%1 : memref<2xf32>) cf.br ^bb3(%1 : memref<2xf32>)
^bb2: ^bb2:
use(%0) use(%0)
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%2: memref<2xf32>): ^bb3(%2: memref<2xf32>):
… …
return return
} }
``` ```
The first alloc can be safely freed after the live range of its post-dominator The first alloc can be safely freed after the live range of its post-dominator
block (bb3). The alloc in bb1 has an alias %2 in bb3 that also keeps this buffer block (bb3). The alloc in bb1 has an alias %2 in bb3 that also keeps this buffer
alive until the end of bb3. Since we cannot determine the actual branches that alive until the end of bb3. Since we cannot determine the actual branches that
will be taken at runtime, we have to ensure that all buffers are freed correctly will be taken at runtime, we have to ensure that all buffers are freed correctly
in bb3 regardless of the branches we will take to reach the exit block. This in bb3 regardless of the branches we will take to reach the exit block. This
makes it necessary to introduce a copy for %2, which allows us to free %alloc0 makes it necessary to introduce a copy for %2, which allows us to free %alloc0
in bb0 and %alloc1 in bb1. Afterwards, we can continue processing all aliases of in bb0 and %alloc1 in bb1. Afterwards, we can continue processing all aliases of
%2 (none in this case) and we can safely free %2 at the end of the sample %2 (none in this case) and we can safely free %2 at the end of the sample
program. This sample demonstrates that not all allocations can be safely freed program. This sample demonstrates that not all allocations can be safely freed
in their associated post-dominator blocks. Instead, we have to pay attention to in their associated post-dominator blocks. Instead, we have to pay attention to
all of their aliases. all of their aliases.
Applying the BufferDeallocation pass to the program above yields the following Applying the BufferDeallocation pass to the program above yields the following
result: result:
```mlir ```mlir
func @branch(%arg0: i1) { func @branch(%arg0: i1) {
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
%1 = memref.alloc() : memref<2xf32> %1 = memref.alloc() : memref<2xf32>
%3 = bufferization.clone %1 : (memref<2xf32>) -> (memref<2xf32>) %3 = bufferization.clone %1 : (memref<2xf32>) -> (memref<2xf32>)
memref.dealloc %1 : memref<2xf32> // %1 can be safely freed here memref.dealloc %1 : memref<2xf32> // %1 can be safely freed here
br ^bb3(%3 : memref<2xf32>) cf.br ^bb3(%3 : memref<2xf32>)
^bb2: ^bb2:
use(%0) use(%0)
%4 = bufferization.clone %0 : (memref<2xf32>) -> (memref<2xf32>) %4 = bufferization.clone %0 : (memref<2xf32>) -> (memref<2xf32>)
br ^bb3(%4 : memref<2xf32>) cf.br ^bb3(%4 : memref<2xf32>)
^bb3(%2: memref<2xf32>): ^bb3(%2: memref<2xf32>):
… …
memref.dealloc %2 : memref<2xf32> // free temp buffer %2 memref.dealloc %2 : memref<2xf32> // free temp buffer %2
memref.dealloc %0 : memref<2xf32> // %0 can be safely freed here memref.dealloc %0 : memref<2xf32> // %0 can be safely freed here
return return
} }
``` ```
Show All 14 Lines
![nested_branch_example_pre_move](/includes/img/nested_branch_example_pre_move.svg) ![nested_branch_example_pre_move](/includes/img/nested_branch_example_pre_move.svg)
```mlir ```mlir
func @condBranchDynamicTypeNested( func @condBranchDynamicTypeNested(
%arg0: i1, %arg0: i1,
%arg1: memref<?xf32>, // aliases: %3, %4 %arg1: memref<?xf32>, // aliases: %3, %4
%arg2: memref<?xf32>, %arg2: memref<?xf32>,
%arg3: index) { %arg3: index) {
cond_br %arg0, ^bb1, ^bb2(%arg3: index) cf.cond_br %arg0, ^bb1, ^bb2(%arg3: index)
^bb1: ^bb1:
br ^bb6(%arg1 : memref<?xf32>) cf.br ^bb6(%arg1 : memref<?xf32>)
^bb2(%0: index): ^bb2(%0: index):
%1 = memref.alloc(%0) : memref<?xf32> // cannot be moved upwards due to the data %1 = memref.alloc(%0) : memref<?xf32> // cannot be moved upwards due to the data
// dependency to %0 // dependency to %0
// aliases: %2, %3, %4 // aliases: %2, %3, %4
use(%1) use(%1)
cond_br %arg0, ^bb3, ^bb4 cf.cond_br %arg0, ^bb3, ^bb4
^bb3: ^bb3:
br ^bb5(%1 : memref<?xf32>) cf.br ^bb5(%1 : memref<?xf32>)
^bb4: ^bb4:
br ^bb5(%1 : memref<?xf32>) cf.br ^bb5(%1 : memref<?xf32>)
^bb5(%2: memref<?xf32>): // non-crit. alias of %1, since %1 dominates %2 ^bb5(%2: memref<?xf32>): // non-crit. alias of %1, since %1 dominates %2
br ^bb6(%2 : memref<?xf32>) cf.br ^bb6(%2 : memref<?xf32>)
^bb6(%3: memref<?xf32>): // crit. alias of %arg1 and %2 (in other words %1) ^bb6(%3: memref<?xf32>): // crit. alias of %arg1 and %2 (in other words %1)
br ^bb7(%3 : memref<?xf32>) cf.br ^bb7(%3 : memref<?xf32>)
^bb7(%4: memref<?xf32>): // non-crit. alias of %3, since %3 dominates %4 ^bb7(%4: memref<?xf32>): // non-crit. alias of %3, since %3 dominates %4
test.copy(%4, %arg2) : (memref<?xf32>, memref<?xf32>) -> () test.copy(%4, %arg2) : (memref<?xf32>, memref<?xf32>) -> ()
return return
} }
``` ```
Applying BufferDeallocation yields the following output: Applying BufferDeallocation yields the following output:
![nested_branch_example_post_move](/includes/img/nested_branch_example_post_move.svg) ![nested_branch_example_post_move](/includes/img/nested_branch_example_post_move.svg)
```mlir ```mlir
func @condBranchDynamicTypeNested( func @condBranchDynamicTypeNested(
%arg0: i1, %arg0: i1,
%arg1: memref<?xf32>, %arg1: memref<?xf32>,
%arg2: memref<?xf32>, %arg2: memref<?xf32>,
%arg3: index) { %arg3: index) {
cond_br %arg0, ^bb1, ^bb2(%arg3 : index) cf.cond_br %arg0, ^bb1, ^bb2(%arg3 : index)
^bb1: ^bb1:
// temp buffer required due to alias %3 // temp buffer required due to alias %3
%5 = bufferization.clone %arg1 : (memref<?xf32>) -> (memref<?xf32>) %5 = bufferization.clone %arg1 : (memref<?xf32>) -> (memref<?xf32>)
br ^bb6(%5 : memref<?xf32>) cf.br ^bb6(%5 : memref<?xf32>)
^bb2(%0: index): ^bb2(%0: index):
%1 = memref.alloc(%0) : memref<?xf32> %1 = memref.alloc(%0) : memref<?xf32>
use(%1) use(%1)
cond_br %arg0, ^bb3, ^bb4 cf.cond_br %arg0, ^bb3, ^bb4
^bb3: ^bb3:
br ^bb5(%1 : memref<?xf32>) cf.br ^bb5(%1 : memref<?xf32>)
^bb4: ^bb4:
br ^bb5(%1 : memref<?xf32>) cf.br ^bb5(%1 : memref<?xf32>)
^bb5(%2: memref<?xf32>): ^bb5(%2: memref<?xf32>):
%6 = bufferization.clone %1 : (memref<?xf32>) -> (memref<?xf32>) %6 = bufferization.clone %1 : (memref<?xf32>) -> (memref<?xf32>)
memref.dealloc %1 : memref<?xf32> memref.dealloc %1 : memref<?xf32>
br ^bb6(%6 : memref<?xf32>) cf.br ^bb6(%6 : memref<?xf32>)
^bb6(%3: memref<?xf32>): ^bb6(%3: memref<?xf32>):
br ^bb7(%3 : memref<?xf32>) cf.br ^bb7(%3 : memref<?xf32>)
^bb7(%4: memref<?xf32>): ^bb7(%4: memref<?xf32>):
test.copy(%4, %arg2) : (memref<?xf32>, memref<?xf32>) -> () test.copy(%4, %arg2) : (memref<?xf32>, memref<?xf32>) -> ()
memref.dealloc %3 : memref<?xf32> // free %3, since %4 is a non-crit. alias of %3 memref.dealloc %3 : memref<?xf32> // free %3, since %4 is a non-crit. alias of %3
return return
} }
``` ```
Since %3 is a critical alias, BufferDeallocation introduces an additional Since %3 is a critical alias, BufferDeallocation introduces an additional
▲ Show 20 Lines • Show All 365 Lines • Show Last 20 Lines

mlir/docs/Diagnostics.md

Show First 20 Lines • Show All 289 Lines • ▼ Show 20 Lines
* `expected-(error|note|remark|warning) {{ message }}` * `expected-(error|note|remark|warning) {{ message }}`
A few examples are shown below: A few examples are shown below:
```mlir ```mlir
// Expect an error on the same line. // Expect an error on the same line.
func @bad_branch() { func @bad_branch() {
br ^missing // expected-error {{reference to an undefined block}} cf.br ^missing // expected-error {{reference to an undefined block}}
} }
// Expect an error on an adjacent line. // Expect an error on an adjacent line.
func @foo(%a : f32) { func @foo(%a : f32) {
// expected-error@+1 {{unknown comparison predicate "foo"}} // expected-error@+1 {{unknown comparison predicate "foo"}}
%result = arith.cmpf "foo", %a, %a : f32 %result = arith.cmpf "foo", %a, %a : f32
return return
} }
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

mlir/docs/DialectConversion.md

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines MyTarget(MLIRContext &ctx) : ConversionTarget(ctx) {
markUnknownOpDynamicallyLegal([](Operation *op) { ... }); markUnknownOpDynamicallyLegal([](Operation *op) { ... });
//-------------------------------------------------------------------------- //--------------------------------------------------------------------------
// Marking an operation as illegal. // Marking an operation as illegal.
/// All operations within the GPU dialect are illegal. /// All operations within the GPU dialect are illegal.
addIllegalDialect<GPUDialect>(); addIllegalDialect<GPUDialect>();
/// Mark `std.br` and `std.cond_br` as illegal. /// Mark `cf.br` and `cf.cond_br` as illegal.
addIllegalOp<BranchOp, CondBranchOp>(); addIllegalOp<cf::BranchOp, cf::CondBranchOp>();
stellaraccidentUnsubmitted
Done
ReplyInline Actions

I am so glad to have these properly namespaced now.

stellaraccident: I am so glad to have these properly namespaced now.
} }
/// Implement the default legalization handler to handle operations marked as /// Implement the default legalization handler to handle operations marked as
/// dynamically legal that were not provided with an explicit handler. /// dynamically legal that were not provided with an explicit handler.
bool isDynamicallyLegal(Operation *op) override { ... } bool isDynamicallyLegal(Operation *op) override { ... }
}; };
``` ```
▲ Show 20 Lines • Show All 326 Lines • Show Last 20 Lines

mlir/docs/Dialects/emitc.md

Show All 17 Lines
After the conversion, C/C++ code can be emitted with `mlir-translate`. The tool After the conversion, C/C++ code can be emitted with `mlir-translate`. The tool
supports translating MLIR to C/C++ by passing `-mlir-to-cpp`. Furthermore, code supports translating MLIR to C/C++ by passing `-mlir-to-cpp`. Furthermore, code
with variables declared at top can be generated by passing the additional with variables declared at top can be generated by passing the additional
argument `-declare-variables-at-top`. argument `-declare-variables-at-top`.
Besides operations part of the EmitC dialect, the Cpp targets supports Besides operations part of the EmitC dialect, the Cpp targets supports
translating the following operations: translating the following operations:
* 'cf' Dialect
* `cf.br`
* `cf.cond_br`
* 'std' Dialect * 'std' Dialect
* `std.br`
* `std.call` * `std.call`
* `std.cond_br`
* `std.constant` * `std.constant`
* `std.return` * `std.return`
* 'scf' Dialect * 'scf' Dialect
* `scf.for` * `scf.for`
* `scf.if` * `scf.if`
* `scf.yield` * `scf.yield`
* 'arith' Dialect * 'arith' Dialect
* `arith.constant` * `arith.constant`

mlir/docs/LangRef.md

Show First 20 Lines • Show All 385 Lines • ▼ Show 20 Lines
not need to be passed through block arguments. not need to be passed through block arguments.
Here is a simple example function showing branches, returns, and block Here is a simple example function showing branches, returns, and block
arguments: arguments:
```mlir ```mlir
func @simple(i64, i1) -> i64 { func @simple(i64, i1) -> i64 {
^bb0(%a: i64, %cond: i1): // Code dominated by ^bb0 may refer to %a ^bb0(%a: i64, %cond: i1): // Code dominated by ^bb0 may refer to %a
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%a: i64) // Branch passes %a as the argument cf.br ^bb3(%a: i64) // Branch passes %a as the argument
^bb2: ^bb2:
%b = arith.addi %a, %a : i64 %b = arith.addi %a, %a : i64
br ^bb3(%b: i64) // Branch passes %b as the argument cf.br ^bb3(%b: i64) // Branch passes %b as the argument
// ^bb3 receives an argument, named %c, from predecessors // ^bb3 receives an argument, named %c, from predecessors
// and passes it on to bb4 along with %a. %a is referenced // and passes it on to bb4 along with %a. %a is referenced
// directly from its defining operation and is not passed through // directly from its defining operation and is not passed through
// an argument of ^bb3. // an argument of ^bb3.
^bb3(%c: i64): ^bb3(%c: i64):
br ^bb4(%c, %a : i64, i64) cf.br ^bb4(%c, %a : i64, i64)
^bb4(%d : i64, %e : i64): ^bb4(%d : i64, %e : i64):
%0 = arith.addi %d, %e : i64 %0 = arith.addi %d, %e : i64
return %0 : i64 // Return is also a terminator. return %0 : i64 // Return is also a terminator.
} }
``` ```
**Context:** The "block argument" representation eliminates a number of special **Context:** The "block argument" representation eliminates a number of special
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines
languages. In addition, control flow may also not reach the end of a block or languages. In addition, control flow may also not reach the end of a block or
region, for example if a function call does not return. region, for example if a function call does not return.
Example: Example:
```mlir ```mlir
func @accelerator_compute(i64, i1) -> i64 { // An SSACFG region func @accelerator_compute(i64, i1) -> i64 { // An SSACFG region
^bb0(%a: i64, %cond: i1): // Code dominated by ^bb0 may refer to %a ^bb0(%a: i64, %cond: i1): // Code dominated by ^bb0 may refer to %a
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
// This def for %value does not dominate ^bb2 // This def for %value does not dominate ^bb2
%value = "op.convert"(%a) : (i64) -> i64 %value = "op.convert"(%a) : (i64) -> i64
br ^bb3(%a: i64) // Branch passes %a as the argument cf.br ^bb3(%a: i64) // Branch passes %a as the argument
^bb2: ^bb2:
accelerator.launch() { // An SSACFG region accelerator.launch() { // An SSACFG region
^bb0: ^bb0:
// Region of code nested under "accelerator.launch", it can reference %a but // Region of code nested under "accelerator.launch", it can reference %a but
// not %value. // not %value.
%new_value = "accelerator.do_something"(%a) : (i64) -> () %new_value = "accelerator.do_something"(%a) : (i64) -> ()
} }
▲ Show 20 Lines • Show All 304 Lines • Show Last 20 Lines

mlir/docs/PatternRewriter.md

Show First 20 Lines • Show All 350 Lines • ▼ Show 20 Lines
application process. This output contains all of the actions performed by the application process. This output contains all of the actions performed by the
rewriter, how operations get processed and patterns are applied, and why they rewriter, how operations get processed and patterns are applied, and why they
fail. fail.
Example output is shown below: Example output is shown below:
``` ```
//===-------------------------------------------===// //===-------------------------------------------===//
Processing operation : 'std.cond_br'(0x60f000001120) { Processing operation : 'cf.cond_br'(0x60f000001120) {
"std.cond_br"(%arg0)[^bb2, ^bb2] {operand_segment_sizes = dense<[1, 0, 0]> : vector<3xi32>} : (i1) -> () "cf.cond_br"(%arg0)[^bb2, ^bb2] {operand_segment_sizes = dense<[1, 0, 0]> : vector<3xi32>} : (i1) -> ()
* Pattern SimplifyConstCondBranchPred : 'std.cond_br -> ()' { * Pattern SimplifyConstCondBranchPred : 'cf.cond_br -> ()' {
} -> failure : pattern failed to match } -> failure : pattern failed to match
* Pattern SimplifyCondBranchIdenticalSuccessors : 'std.cond_br -> ()' { * Pattern SimplifyCondBranchIdenticalSuccessors : 'cf.cond_br -> ()' {
** Insert : 'std.br'(0x60b000003690) ** Insert : 'cf.br'(0x60b000003690)
** Replace : 'std.cond_br'(0x60f000001120) ** Replace : 'cf.cond_br'(0x60f000001120)
} -> success : pattern applied successfully } -> success : pattern applied successfully
} -> success : pattern matched } -> success : pattern matched
//===-------------------------------------------===// //===-------------------------------------------===//
``` ```
This output is describing the processing of a `std.cond_br` operation. We first This output is describing the processing of a `cf.cond_br` operation. We first
try to apply the `SimplifyConstCondBranchPred`, which fails. From there, another try to apply the `SimplifyConstCondBranchPred`, which fails. From there, another
pattern (`SimplifyCondBranchIdenticalSuccessors`) is applied that matches the pattern (`SimplifyCondBranchIdenticalSuccessors`) is applied that matches the
`std.cond_br` and replaces it with a `std.br`. `cf.cond_br` and replaces it with a `cf.br`.
## Debugging ## Debugging
### Pattern Filtering ### Pattern Filtering
To simplify test case definition and reduction, the `FrozenRewritePatternSet` To simplify test case definition and reduction, the `FrozenRewritePatternSet`
class provides built-in support for filtering which patterns should be provided class provides built-in support for filtering which patterns should be provided
to the pattern driver for application. Filtering behavior is specified by to the pattern driver for application. Filtering behavior is specified by
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

mlir/docs/Rationale/Rationale.md

Show First 20 Lines • Show All 554 Lines • ▼ Show 20 Linesfunc @search(%A: memref<?x?xi32>, %S: <?xi32>, %key : i32) {
affine.for %i = 0 to %ni { affine.for %i = 0 to %ni {
call @search_body (%A, %S, %key, %i) : (memref<?x?xi32>, memref<?xi32>, i32, i32) call @search_body (%A, %S, %key, %i) : (memref<?x?xi32>, memref<?xi32>, i32, i32)
} }
return return
} }
func @search_body(%A: memref<?x?xi32>, %S: memref<?xi32>, %key: i32, %i : i32) { func @search_body(%A: memref<?x?xi32>, %S: memref<?xi32>, %key: i32, %i : i32) {
%nj = memref.dim %A, 1 : memref<?x?xi32> %nj = memref.dim %A, 1 : memref<?x?xi32>
br ^bb1(0) cf.br ^bb1(0)
^bb1(%j: i32) ^bb1(%j: i32)
%p1 = arith.cmpi "lt", %j, %nj : i32 %p1 = arith.cmpi "lt", %j, %nj : i32
cond_br %p1, ^bb2, ^bb5 cf.cond_br %p1, ^bb2, ^bb5
^bb2: ^bb2:
%v = affine.load %A[%i, %j] : memref<?x?xi32> %v = affine.load %A[%i, %j] : memref<?x?xi32>
%p2 = arith.cmpi "eq", %v, %key : i32 %p2 = arith.cmpi "eq", %v, %key : i32
cond_br %p2, ^bb3(%j), ^bb4 cf.cond_br %p2, ^bb3(%j), ^bb4
^bb3(%j: i32) ^bb3(%j: i32)
affine.store %j, %S[%i] : memref<?xi32> affine.store %j, %S[%i] : memref<?xi32>
br ^bb5 cf.br ^bb5
^bb4: ^bb4:
%jinc = arith.addi %j, 1 : i32 %jinc = arith.addi %j, 1 : i32
br ^bb1(%jinc) cf.br ^bb1(%jinc)
^bb5: ^bb5:
return return
} }
``` ```
As per the [MLIR spec](../LangRef.md), the restrictions on dimensions and symbol As per the [MLIR spec](../LangRef.md), the restrictions on dimensions and symbol
identifiers to be used with the affine.apply operation only apply to accesses identifiers to be used with the affine.apply operation only apply to accesses
▲ Show 20 Lines • Show All 477 Lines • Show Last 20 Lines

mlir/docs/Tutorials/Toy/Ch-6.md

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines
`affine`, `arith`, and `std` dialects already provide the set of patterns needed `affine`, `arith`, and `std` dialects already provide the set of patterns needed
to transform them into LLVM dialect. These patterns allow for lowering the IR in to transform them into LLVM dialect. These patterns allow for lowering the IR in
multiple stages by relying on multiple stages by relying on
[transitive lowering](../../../getting_started/Glossary.md/#transitive-lowering). [transitive lowering](../../../getting_started/Glossary.md/#transitive-lowering).
```c++ ```c++
mlir::RewritePatternSet patterns(&getContext()); mlir::RewritePatternSet patterns(&getContext());
mlir::populateAffineToStdConversionPatterns(patterns, &getContext()); mlir::populateAffineToStdConversionPatterns(patterns, &getContext());
mlir::populateLoopToStdConversionPatterns(patterns, &getContext()); mlir::cf::populateSCFToControlFlowConversionPatterns(patterns, &getContext());
mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter, mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
patterns); patterns);
mlir::populateStdToLLVMConversionPatterns(typeConverter, patterns); mlir::populateStdToLLVMConversionPatterns(typeConverter, patterns);
mlir::cf::populateControlFlowToLLVMConversionPatterns(patterns, &getContext());
// The only remaining operation, to lower from the `toy` dialect, is the // The only remaining operation, to lower from the `toy` dialect, is the
// PrintOp. // PrintOp.
patterns.add<PrintOpLowering>(&getContext()); patterns.add<PrintOpLowering>(&getContext());
``` ```
### Full Lowering ### Full Lowering
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines102:
%104 = mul i64 %96, 2 %104 = mul i64 %96, 2
%105 = add i64 0, %104 %105 = add i64 0, %104
%106 = mul i64 %100, 1 %106 = mul i64 %100, 1
%107 = add i64 %105, %106 %107 = add i64 %105, %106
%108 = getelementptr double, double* %103, i64 %107 %108 = getelementptr double, double* %103, i64 %107
%109 = memref.load double, double* %108 %109 = memref.load double, double* %108
%110 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @frmt_spec, i64 0, i64 0), double %109) %110 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @frmt_spec, i64 0, i64 0), double %109)
%111 = add i64 %100, 1 %111 = add i64 %100, 1
br label %99 cf.br label %99
... ...
115: 115:
%116 = extractvalue { double*, i64, [2 x i64], [2 x i64] } %24, 0 %116 = extractvalue { double*, i64, [2 x i64], [2 x i64] } %24, 0
%117 = bitcast double* %116 to i8* %117 = bitcast double* %116 to i8*
call void @free(i8* %117) call void @free(i8* %117)
%118 = extractvalue { double*, i64, [2 x i64], [2 x i64] } %16, 0 %118 = extractvalue { double*, i64, [2 x i64], [2 x i64] } %16, 0
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

mlir/docs/includes/img/branch_example_post_move.svg

Show First 20 Lines • Show All 355 Lines • ▼ Show 20 Lines <text
style="font-size:5.64444px"> style="font-size:5.64444px">
</tspan></tspan><tspan </tspan></tspan><tspan
x="73.476562" x="73.476562"
y="81.238347"><tspan y="81.238347"><tspan
style="font-size:5.64444px">use(%0) style="font-size:5.64444px">use(%0)
</tspan></tspan><tspan </tspan></tspan><tspan
x="73.476562" x="73.476562"
y="88.293896"><tspan y="88.293896"><tspan
style="font-size:5.64444px">br bb3(%0)</tspan></tspan></text> style="font-size:5.64444px">cf.br bb3(%0)</tspan></tspan></text>
<text <text
xml:space="preserve" xml:space="preserve"
id="text1894" id="text1894"
style="font-style:normal;font-weight:normal;font-size:5.64444000000000035px;line-height:1.25;font-family:sans-serif;white-space:pre;shape-inside:url(#rect1896);fill:#000000;fill-opacity:1;stroke:none;" /> style="font-style:normal;font-weight:normal;font-size:5.64444000000000035px;line-height:1.25;font-family:sans-serif;white-space:pre;shape-inside:url(#rect1896);fill:#000000;fill-opacity:1;stroke:none;" />
<text <text
xml:space="preserve" xml:space="preserve"
style="font-style:normal;font-weight:normal;font-size:5.64444px;line-height:1.25;font-family:sans-serif;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.264583" style="font-style:normal;font-weight:normal;font-size:5.64444px;line-height:1.25;font-family:sans-serif;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.264583"
x="16.620224" x="16.620224"
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

mlir/docs/includes/img/branch_example_pre_move.svg

Show First 20 Lines • Show All 356 Lines • ▼ Show 20 Lines <text
style="font-size:5.64444px"> style="font-size:5.64444px">
</tspan></tspan><tspan </tspan></tspan><tspan
x="73.476562" x="73.476562"
y="81.238347"><tspan y="81.238347"><tspan
style="font-size:5.64444px">use(%0) style="font-size:5.64444px">use(%0)
</tspan></tspan><tspan </tspan></tspan><tspan
x="73.476562" x="73.476562"
y="88.293896"><tspan y="88.293896"><tspan
style="font-size:5.64444px">br bb3(%0)</tspan></tspan></text> style="font-size:5.64444px">cf.br bb3(%0)</tspan></tspan></text>
<text <text
xml:space="preserve" xml:space="preserve"
id="text1894" id="text1894"
style="font-style:normal;font-weight:normal;font-size:5.64444000000000035px;line-height:1.25;font-family:sans-serif;white-space:pre;shape-inside:url(#rect1896);fill:#000000;fill-opacity:1;stroke:none;" /> style="font-style:normal;font-weight:normal;font-size:5.64444000000000035px;line-height:1.25;font-family:sans-serif;white-space:pre;shape-inside:url(#rect1896);fill:#000000;fill-opacity:1;stroke:none;" />
<text <text
xml:space="preserve" xml:space="preserve"
style="font-style:normal;font-weight:normal;font-size:5.64444px;line-height:1.25;font-family:sans-serif;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.264583" style="font-style:normal;font-weight:normal;font-size:5.64444px;line-height:1.25;font-family:sans-serif;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.264583"
x="16.620224" x="16.620224"
Show All 36 Lines

mlir/examples/toy/Ch6/mlir/LowerToLLVM.cpp

Show All 20 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "toy/Dialect.h" #include "toy/Dialect.h"
#include "toy/Passes.h" #include "toy/Passes.h"
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h" #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/SCFToStandard/SCFToStandard.h" #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
▲ Show 20 Lines • Show All 154 Lines • ▼ Show 20 Linesvoid ToyToLLVMLoweringPass::runOnOperation() {
// have a combination of `toy`, `affine`, and `std` operations. Luckily, there // have a combination of `toy`, `affine`, and `std` operations. Luckily, there
// are already exists a set of patterns to transform `affine` and `std` // are already exists a set of patterns to transform `affine` and `std`
// dialects. These patterns lowering in multiple stages, relying on transitive // dialects. These patterns lowering in multiple stages, relying on transitive
// lowerings. Transitive lowering, or A->B->C lowering, is when multiple // lowerings. Transitive lowering, or A->B->C lowering, is when multiple
// patterns must be applied to fully transform an illegal operation into a // patterns must be applied to fully transform an illegal operation into a
// set of legal ones. // set of legal ones.
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateAffineToStdConversionPatterns(patterns); populateAffineToStdConversionPatterns(patterns);
populateLoopToStdConversionPatterns(patterns); populateSCFToControlFlowConversionPatterns(patterns);
mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter, mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
patterns); patterns);
populateMemRefToLLVMConversionPatterns(typeConverter, patterns); populateMemRefToLLVMConversionPatterns(typeConverter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
populateStdToLLVMConversionPatterns(typeConverter, patterns); populateStdToLLVMConversionPatterns(typeConverter, patterns);
// The only remaining operation to lower from the `toy` dialect, is the // The only remaining operation to lower from the `toy` dialect, is the
// PrintOp. // PrintOp.
patterns.add<PrintOpLowering>(&getContext()); patterns.add<PrintOpLowering>(&getContext());
// We want to completely lower to LLVM, so we use a `FullConversion`. This // We want to completely lower to LLVM, so we use a `FullConversion`. This
// ensures that only legal operations will remain after the conversion. // ensures that only legal operations will remain after the conversion.
Show All 10 Lines

mlir/examples/toy/Ch7/mlir/LowerToLLVM.cpp

Show All 20 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "toy/Dialect.h" #include "toy/Dialect.h"
#include "toy/Passes.h" #include "toy/Passes.h"
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h" #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/SCFToStandard/SCFToStandard.h" #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
▲ Show 20 Lines • Show All 154 Lines • ▼ Show 20 Linesvoid ToyToLLVMLoweringPass::runOnOperation() {
// have a combination of `toy`, `affine`, and `std` operations. Luckily, there // have a combination of `toy`, `affine`, and `std` operations. Luckily, there
// are already exists a set of patterns to transform `affine` and `std` // are already exists a set of patterns to transform `affine` and `std`
// dialects. These patterns lowering in multiple stages, relying on transitive // dialects. These patterns lowering in multiple stages, relying on transitive
// lowerings. Transitive lowering, or A->B->C lowering, is when multiple // lowerings. Transitive lowering, or A->B->C lowering, is when multiple
// patterns must be applied to fully transform an illegal operation into a // patterns must be applied to fully transform an illegal operation into a
// set of legal ones. // set of legal ones.
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateAffineToStdConversionPatterns(patterns); populateAffineToStdConversionPatterns(patterns);
populateLoopToStdConversionPatterns(patterns); populateSCFToControlFlowConversionPatterns(patterns);
mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter, mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
patterns); patterns);
populateMemRefToLLVMConversionPatterns(typeConverter, patterns); populateMemRefToLLVMConversionPatterns(typeConverter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
populateStdToLLVMConversionPatterns(typeConverter, patterns); populateStdToLLVMConversionPatterns(typeConverter, patterns);
// The only remaining operation to lower from the `toy` dialect, is the // The only remaining operation to lower from the `toy` dialect, is the
// PrintOp. // PrintOp.
patterns.add<PrintOpLowering>(&getContext()); patterns.add<PrintOpLowering>(&getContext());
// We want to completely lower to LLVM, so we use a `FullConversion`. This // We want to completely lower to LLVM, so we use a `FullConversion`. This
// ensures that only legal operations will remain after the conversion. // ensures that only legal operations will remain after the conversion.
Show All 10 Lines

mlir/include/mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h

  • This file was added.
//===- ControlFlowToLLVM.h - ControlFlow to LLVM -----------*- C++ ------*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Define conversions from the ControlFlow dialect to the LLVM IR dialect.
//
//===----------------------------------------------------------------------===//
#ifndef MLIR_CONVERSION_CONTROLFLOWTOLLVM_CONTROLFLOWTOLLVM_H
#define MLIR_CONVERSION_CONTROLFLOWTOLLVM_CONTROLFLOWTOLLVM_H
#include <memory>
namespace mlir {
class LLVMTypeConverter;
class RewritePatternSet;
class Pass;
namespace cf {
/// Collect the patterns to convert from the ControlFlow dialect to LLVM. The
/// conversion patterns capture the LLVMTypeConverter by reference meaning the
/// references have to remain alive during the entire pattern lifetime.
void populateControlFlowToLLVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns);
/// Creates a pass to convert the ControlFlow dialect into the LLVMIR dialect.
std::unique_ptr<Pass> createConvertControlFlowToLLVMPass();
} // namespace cf
} // namespace mlir
#endif // MLIR_CONVERSION_CONTROLFLOWTOLLVM_CONTROLFLOWTOLLVM_H

mlir/include/mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRV.h

  • This file was added.
//===- ControlFlowToSPIRV.h - CF to SPIR-V Patterns --------*- C++ ------*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Provides patterns to convert ControlFlow dialect to SPIR-V dialect.
//
//===----------------------------------------------------------------------===//
#ifndef MLIR_CONVERSION_CONTROLFLOWTOSPIRV_CONTROLFLOWTOSPIRV_H
#define MLIR_CONVERSION_CONTROLFLOWTOSPIRV_CONTROLFLOWTOSPIRV_H
namespace mlir {
class RewritePatternSet;
MogballUnsubmitted
Done
ReplyInline Actions

Is this the right include?

Mogball: Is this the right include?
stellaraccidentUnsubmitted
Done
ReplyInline Actions

Seems like we should just not include anything and forward declare RewritePatternSet (that is what ControlFlowToLLVM does)

stellaraccident: Seems like we should just not include anything and forward declare RewritePatternSet (that is…
rriddleAuthorUnsubmitted
Done
ReplyInline Actions

Yep, thanks for pointing all of these out (just copied from the original file, which should also be doing the same)

rriddle: Yep, thanks for pointing all of these out (just copied from the original file, which should…
class SPIRVTypeConverter;
namespace cf {
/// Appends to a pattern list additional patterns for translating ControlFLow
/// ops to SPIR-V ops.
void populateControlFlowToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
RewritePatternSet &patterns);
} // namespace cf
} // namespace mlir
#endif // MLIR_CONVERSION_CONTROLFLOWTOSPIRV_CONTROLFLOWTOSPIRV_H

mlir/include/mlir/Conversion/Passes.h

Show All 11 Lines
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h" #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h" #include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h"
#include "mlir/Conversion/ArmNeon2dToIntr/ArmNeon2dToIntr.h" #include "mlir/Conversion/ArmNeon2dToIntr/ArmNeon2dToIntr.h"
#include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h" #include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h"
#include "mlir/Conversion/BufferizationToMemRef/BufferizationToMemRef.h" #include "mlir/Conversion/BufferizationToMemRef/BufferizationToMemRef.h"
#include "mlir/Conversion/ComplexToLLVM/ComplexToLLVM.h" #include "mlir/Conversion/ComplexToLLVM/ComplexToLLVM.h"
#include "mlir/Conversion/ComplexToStandard/ComplexToStandard.h" #include "mlir/Conversion/ComplexToStandard/ComplexToStandard.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRV.h"
#include "mlir/Conversion/GPUCommon/GPUCommonPass.h" #include "mlir/Conversion/GPUCommon/GPUCommonPass.h"
#include "mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h" #include "mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h"
#include "mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h" #include "mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h"
#include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h" #include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h"
#include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h" #include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
#include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h" #include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
#include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h" #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h"
#include "mlir/Conversion/LinalgToStandard/LinalgToStandard.h" #include "mlir/Conversion/LinalgToStandard/LinalgToStandard.h"
#include "mlir/Conversion/MathToLLVM/MathToLLVM.h" #include "mlir/Conversion/MathToLLVM/MathToLLVM.h"
#include "mlir/Conversion/MathToLibm/MathToLibm.h" #include "mlir/Conversion/MathToLibm/MathToLibm.h"
#include "mlir/Conversion/MathToSPIRV/MathToSPIRVPass.h" #include "mlir/Conversion/MathToSPIRV/MathToSPIRVPass.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRVPass.h" #include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRVPass.h"
#include "mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h" #include "mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h"
#include "mlir/Conversion/OpenACCToSCF/ConvertOpenACCToSCF.h" #include "mlir/Conversion/OpenACCToSCF/ConvertOpenACCToSCF.h"
#include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h" #include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h"
#include "mlir/Conversion/PDLToPDLInterp/PDLToPDLInterp.h" #include "mlir/Conversion/PDLToPDLInterp/PDLToPDLInterp.h"
#include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h" #include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Conversion/SCFToGPU/SCFToGPUPass.h" #include "mlir/Conversion/SCFToGPU/SCFToGPUPass.h"
#include "mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h" #include "mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h"
#include "mlir/Conversion/SCFToSPIRV/SCFToSPIRVPass.h" #include "mlir/Conversion/SCFToSPIRV/SCFToSPIRVPass.h"
#include "mlir/Conversion/SCFToStandard/SCFToStandard.h"
#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h" #include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
#include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h" #include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Conversion/StandardToSPIRV/StandardToSPIRVPass.h" #include "mlir/Conversion/StandardToSPIRV/StandardToSPIRVPass.h"
#include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h" #include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h"
#include "mlir/Conversion/TosaToSCF/TosaToSCF.h" #include "mlir/Conversion/TosaToSCF/TosaToSCF.h"
#include "mlir/Conversion/TosaToStandard/TosaToStandard.h" #include "mlir/Conversion/TosaToStandard/TosaToStandard.h"
#include "mlir/Conversion/VectorToGPU/VectorToGPU.h" #include "mlir/Conversion/VectorToGPU/VectorToGPU.h"
Show All 14 Lines

mlir/include/mlir/Conversion/Passes.td

Show First 20 Lines • Show All 176 Lines • ▼ Show 20 Lines
def ConvertComplexToStandard : Pass<"convert-complex-to-standard", "FuncOp"> { def ConvertComplexToStandard : Pass<"convert-complex-to-standard", "FuncOp"> {
let summary = "Convert Complex dialect to standard dialect"; let summary = "Convert Complex dialect to standard dialect";
let constructor = "mlir::createConvertComplexToStandardPass()"; let constructor = "mlir::createConvertComplexToStandardPass()";
let dependentDialects = ["math::MathDialect"]; let dependentDialects = ["math::MathDialect"];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ControlFlowToLLVM
//===----------------------------------------------------------------------===//
def ConvertControlFlowToLLVM : Pass<"convert-cf-to-llvm", "ModuleOp"> {
stellaraccidentUnsubmitted
Done
ReplyInline Actions

Does this really need to be a Module-pass? The Standard->* passes look like they were all Module-passes, but I wonder how much that is legacy and doesn't apply to a more focused dialect.

stellaraccident: Does this really need to be a Module-pass? The Standard->* passes look like they were all…
rriddleAuthorUnsubmitted
Done
ReplyInline Actions

Yep, AssertOp may insert a function as part of the lowering (which requires updating the module).

rriddle: Yep, AssertOp may insert a function as part of the lowering (which requires updating the…
let summary = "Convert ControlFlow operations to the LLVM dialect";
let description = [{
Convert ControlFlow operations into LLVM IR dialect operations.
If other operations are present and their results are required by the LLVM
IR dialect operations, the pass will fail. Any LLVM IR operations or types
already present in the IR will be kept as is.
}];
let constructor = "mlir::cf::createConvertControlFlowToLLVMPass()";
let dependentDialects = ["LLVM::LLVMDialect"];
let options = [
Option<"indexBitwidth", "index-bitwidth", "unsigned",
/*default=kDeriveIndexBitwidthFromDataLayout*/"0",
"Bitwidth of the index type, 0 to use size of machine word">,
];
}
//===----------------------------------------------------------------------===//
// GPUCommon // GPUCommon
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def GpuToLLVMConversionPass : Pass<"gpu-to-llvm", "ModuleOp"> { def GpuToLLVMConversionPass : Pass<"gpu-to-llvm", "ModuleOp"> {
let summary = "Convert GPU dialect to LLVM dialect with GPU runtime calls"; let summary = "Convert GPU dialect to LLVM dialect with GPU runtime calls";
let constructor = "mlir::createGpuToLLVMConversionPass()"; let constructor = "mlir::createGpuToLLVMConversionPass()";
let dependentDialects = ["LLVM::LLVMDialect"]; let dependentDialects = ["LLVM::LLVMDialect"];
} }
▲ Show 20 Lines • Show All 263 Lines • ▼ Show 20 Lines let description = [{
Such situations appear when the consumer operation is converted by one pass Such situations appear when the consumer operation is converted by one pass
and the producer operation is converted by another pass, each of which and the producer operation is converted by another pass, each of which
produces an unrealized cast. This pass can be used to clean up the IR. produces an unrealized cast. This pass can be used to clean up the IR.
}]; }];
let constructor = "mlir::createReconcileUnrealizedCastsPass()"; let constructor = "mlir::createReconcileUnrealizedCastsPass()";
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// SCFToControlFlow
//===----------------------------------------------------------------------===//
def SCFToControlFlow : Pass<"convert-scf-to-cf"> {
let summary = "Convert SCF dialect to ControlFlow dialect, replacing structured"
" control flow with a CFG";
let constructor = "mlir::createConvertSCFToCFPass()";
let dependentDialects = ["cf::ControlFlowDialect"];
}
//===----------------------------------------------------------------------===//
// SCFToOpenMP // SCFToOpenMP
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ConvertSCFToOpenMP : Pass<"convert-scf-to-openmp", "ModuleOp"> { def ConvertSCFToOpenMP : Pass<"convert-scf-to-openmp", "ModuleOp"> {
let summary = "Convert SCF parallel loop to OpenMP parallel + workshare " let summary = "Convert SCF parallel loop to OpenMP parallel + workshare "
"constructs."; "constructs.";
let constructor = "mlir::createConvertSCFToOpenMPPass()"; let constructor = "mlir::createConvertSCFToOpenMPPass()";
let dependentDialects = ["omp::OpenMPDialect", "LLVM::LLVMDialect"]; let dependentDialects = ["omp::OpenMPDialect", "LLVM::LLVMDialect"];
Show All 12 Lines let description = [{
holding the values and load/store operations are emitted for updating holding the values and load/store operations are emitted for updating
them. them.
}]; }];
let constructor = "mlir::createConvertSCFToSPIRVPass()"; let constructor = "mlir::createConvertSCFToSPIRVPass()";
let dependentDialects = ["spirv::SPIRVDialect"]; let dependentDialects = ["spirv::SPIRVDialect"];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// SCFToStandard
//===----------------------------------------------------------------------===//
def SCFToStandard : Pass<"convert-scf-to-std"> {
let summary = "Convert SCF dialect to Standard dialect, replacing structured"
" control flow with a CFG";
let constructor = "mlir::createLowerToCFGPass()";
let dependentDialects = ["StandardOpsDialect"];
}
//===----------------------------------------------------------------------===//
// SCFToGPU // SCFToGPU
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ConvertAffineForToGPU : Pass<"convert-affine-for-to-gpu", "FuncOp"> { def ConvertAffineForToGPU : Pass<"convert-affine-for-to-gpu", "FuncOp"> {
let summary = "Convert top-level AffineFor Ops to GPU kernels"; let summary = "Convert top-level AffineFor Ops to GPU kernels";
let constructor = "mlir::createAffineForToGPUPass()"; let constructor = "mlir::createAffineForToGPUPass()";
let dependentDialects = ["gpu::GPUDialect"]; let dependentDialects = ["gpu::GPUDialect"];
let options = [ let options = [
Show All 31 Lines let description = [{
eager (side-effecting) error handling code. eager (side-effecting) error handling code.
This pass is separate from the regular convert-shape-to-standard, despite This pass is separate from the regular convert-shape-to-standard, despite
converting between the same dialects, because converting shape constraints converting between the same dialects, because converting shape constraints
can happen at a different part of the program than general shape can happen at a different part of the program than general shape
computation lowering. computation lowering.
}]; }];
let constructor = "mlir::createConvertShapeConstraintsPass()"; let constructor = "mlir::createConvertShapeConstraintsPass()";
let dependentDialects = ["StandardOpsDialect", "scf::SCFDialect"]; let dependentDialects = ["cf::ControlFlowDialect", "scf::SCFDialect"];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// SPIRVToLLVM // SPIRVToLLVM
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ConvertSPIRVToLLVM : Pass<"convert-spirv-to-llvm", "ModuleOp"> { def ConvertSPIRVToLLVM : Pass<"convert-spirv-to-llvm", "ModuleOp"> {
let summary = "Convert SPIR-V dialect to LLVM dialect"; let summary = "Convert SPIR-V dialect to LLVM dialect";
▲ Show 20 Lines • Show All 257 Lines • Show Last 20 Lines

mlir/include/mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h

  • This file was added.
//===- ConvertSCFToControlFlow.h - Pass entrypoint --------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef MLIR_CONVERSION_SCFTOCONTROLFLOW_SCFTOCONTROLFLOW_H_
#define MLIR_CONVERSION_SCFTOCONTROLFLOW_SCFTOCONTROLFLOW_H_
#include <memory>
namespace mlir {
MogballUnsubmitted
Done
ReplyInline Actions

Unused include?

Mogball: Unused include?
class Pass;
class RewritePatternSet;
/// Collect a set of patterns to convert SCF operations to CFG branch-based
/// operations within the ControlFlow dialect.
MogballUnsubmitted
Done
ReplyInline Actions
struct LogicalResult;
class Pass;
-
class RewritePatternSet;
Mogball:
void populateSCFToControlFlowConversionPatterns(RewritePatternSet &patterns);
/// Creates a pass to convert SCF operations to CFG branch-based operation in
/// the ControlFlow dialect.
std::unique_ptr<Pass> createConvertSCFToCFPass();
} // namespace mlir
#endif // MLIR_CONVERSION_SCFTOCONTROLFLOW_SCFTOCONTROLFLOW_H_

mlir/include/mlir/Conversion/SCFToStandard/SCFToStandard.h

  • This file was deleted.
//===- ConvertSCFToStandard.h - Pass entrypoint -----------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef MLIR_CONVERSION_SCFTOSTANDARD_SCFTOSTANDARD_H_
#define MLIR_CONVERSION_SCFTOSTANDARD_SCFTOSTANDARD_H_
#include <memory>
#include <vector>
namespace mlir {
struct LogicalResult;
class Pass;
class RewritePatternSet;
/// Collect a set of patterns to lower from scf.for, scf.if, and
/// loop.terminator to CFG operations within the Standard dialect, in particular
/// convert structured control flow into CFG branch-based control flow.
void populateLoopToStdConversionPatterns(RewritePatternSet &patterns);
/// Creates a pass to convert scf.for, scf.if and loop.terminator ops to CFG.
std::unique_ptr<Pass> createLowerToCFGPass();
} // namespace mlir
#endif // MLIR_CONVERSION_SCFTOSTANDARD_SCFTOSTANDARD_H_

mlir/include/mlir/Dialect/Bufferization/Transforms/Passes.td

Show All 20 Lines let description = [{
Input Input
```mlir ```mlir
#map0 = affine_map<(d0) -> (d0)> #map0 = affine_map<(d0) -> (d0)>
module { module {
func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
linalg.generic { linalg.generic {
args_in = 1 : i64, args_in = 1 : i64,
args_out = 1 : i64, args_out = 1 : i64,
indexing_maps = [#map0, #map0], indexing_maps = [#map0, #map0],
iterator_types = ["parallel"]} %arg1, %0 { iterator_types = ["parallel"]} %arg1, %0 {
^bb0(%gen1_arg0: f32, %gen1_arg1: f32): ^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
%tmp1 = exp %gen1_arg0 : f32 %tmp1 = exp %gen1_arg0 : f32
linalg.yield %tmp1 : f32 linalg.yield %tmp1 : f32
}: memref<2xf32>, memref<2xf32> }: memref<2xf32>, memref<2xf32>
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
"memref.copy"(%1, %arg2) : (memref<2xf32>, memref<2xf32>) -> () "memref.copy"(%1, %arg2) : (memref<2xf32>, memref<2xf32>) -> ()
return return
} }
} }
``` ```
Output Output
```mlir ```mlir
#map0 = affine_map<(d0) -> (d0)> #map0 = affine_map<(d0) -> (d0)>
module { module {
func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
memref.copy(%arg1, %0) : memref<2xf32>, memref<2xf32> memref.copy(%arg1, %0) : memref<2xf32>, memref<2xf32>
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb2: // pred: ^bb0 ^bb2: // pred: ^bb0
%1 = memref.alloc() : memref<2xf32> %1 = memref.alloc() : memref<2xf32>
linalg.generic { linalg.generic {
args_in = 1 : i64, args_in = 1 : i64,
args_out = 1 : i64, args_out = 1 : i64,
indexing_maps = [#map0, #map0], indexing_maps = [#map0, #map0],
iterator_types = ["parallel"]} %arg1, %1 { iterator_types = ["parallel"]} %arg1, %1 {
^bb0(%arg3: f32, %arg4: f32): ^bb0(%arg3: f32, %arg4: f32):
%4 = exp %arg3 : f32 %4 = exp %arg3 : f32
linalg.yield %4 : f32 linalg.yield %4 : f32
}: memref<2xf32>, memref<2xf32> }: memref<2xf32>, memref<2xf32>
%2 = memref.alloc() : memref<2xf32> %2 = memref.alloc() : memref<2xf32>
memref.copy(%1, %2) : memref<2xf32>, memref<2xf32> memref.copy(%1, %2) : memref<2xf32>, memref<2xf32>
dealloc %1 : memref<2xf32> dealloc %1 : memref<2xf32>
br ^bb3(%2 : memref<2xf32>) cf.br ^bb3(%2 : memref<2xf32>)
^bb3(%3: memref<2xf32>): // 2 preds: ^bb1, ^bb2 ^bb3(%3: memref<2xf32>): // 2 preds: ^bb1, ^bb2
memref.copy(%3, %arg2) : memref<2xf32>, memref<2xf32> memref.copy(%3, %arg2) : memref<2xf32>, memref<2xf32>
dealloc %3 : memref<2xf32> dealloc %3 : memref<2xf32>
return return
} }
} }
``` ```
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/CMakeLists.txt

add_subdirectory(Affine) add_subdirectory(Affine)
add_subdirectory(Arithmetic) add_subdirectory(Arithmetic)
add_subdirectory(Async) add_subdirectory(Async)
add_subdirectory(ArmNeon) add_subdirectory(ArmNeon)
add_subdirectory(ArmSVE) add_subdirectory(ArmSVE)
add_subdirectory(AMX) add_subdirectory(AMX)
add_subdirectory(Bufferization) add_subdirectory(Bufferization)
add_subdirectory(Complex) add_subdirectory(Complex)
add_subdirectory(ControlFlow)
add_subdirectory(DLTI) add_subdirectory(DLTI)
add_subdirectory(EmitC) add_subdirectory(EmitC)
add_subdirectory(GPU) add_subdirectory(GPU)
add_subdirectory(Math) add_subdirectory(Math)
add_subdirectory(Linalg) add_subdirectory(Linalg)
add_subdirectory(LLVMIR) add_subdirectory(LLVMIR)
add_subdirectory(MemRef) add_subdirectory(MemRef)
add_subdirectory(OpenACC) add_subdirectory(OpenACC)
Show All 13 Lines

mlir/include/mlir/Dialect/ControlFlow/CMakeLists.txt

  • This file was added.
add_subdirectory(IR)

mlir/include/mlir/Dialect/ControlFlow/IR/CMakeLists.txt

  • This file was added.
add_mlir_dialect(ControlFlowOps cf ControlFlowOps)
add_mlir_doc(ControlFlowOps ControlFlowDialect Dialects/ -gen-dialect-doc)

mlir/include/mlir/Dialect/ControlFlow/IR/ControlFlow.h

  • This file was added.
//===- ControlFlow.h - ControlFlow Dialect ----------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines the ControlFlow dialect.
//
//===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_CONTROLFLOW_IR_CONTROLFLOW_H
#define MLIR_DIALECT_CONTROLFLOW_IR_CONTROLFLOW_H
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/IR/Dialect.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOpsDialect.h.inc"
#endif // MLIR_DIALECT_CONTROLFLOW_IR_CONTROLFLOW_H

mlir/include/mlir/Dialect/ControlFlow/IR/ControlFlowOps.h

  • This file was added.
//===- ControlFlowOps.h - ControlFlow Operations ----------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines the operations of the ControlFlow dialect.
//
//===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_CONTROLFLOW_IR_CONTROLFLOWOPS_H
#define MLIR_DIALECT_CONTROLFLOW_IR_CONTROLFLOWOPS_H
#include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/OpImplementation.h"
#include "mlir/Interfaces/ControlFlowInterfaces.h"
#include "mlir/Interfaces/SideEffectInterfaces.h"
namespace mlir {
class PatternRewriter;
} // namespace mlir
#define GET_OP_CLASSES
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h.inc"
#endif // MLIR_DIALECT_CONTROLFLOW_IR_CONTROLFLOWOPS_H

mlir/include/mlir/Dialect/ControlFlow/IR/ControlFlowOps.td

  • This file was copied from mlir/include/mlir/Dialect/StandardOps/IR/Ops.td.
//===- Ops.td - Standard operation definitions -------------*- tablegen -*-===// //===- ControlFlowOps.td - ControlFlow operations ----------*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Defines some MLIR standard operations. // This file contains definitions for the operations within the ControlFlow
// dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef STANDARD_OPS #ifndef STANDARD_OPS
#define STANDARD_OPS #define STANDARD_OPS
include "mlir/IR/OpAsmInterface.td" include "mlir/IR/OpAsmInterface.td"
include "mlir/IR/SymbolInterfaces.td"
include "mlir/Interfaces/CallInterfaces.td"
include "mlir/Interfaces/CastInterfaces.td"
include "mlir/Interfaces/ControlFlowInterfaces.td" include "mlir/Interfaces/ControlFlowInterfaces.td"
include "mlir/Interfaces/InferTypeOpInterface.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
include "mlir/Interfaces/VectorInterfaces.td"
def StandardOps_Dialect : Dialect { def ControlFlow_Dialect : Dialect {
let name = "std"; let name = "cf";
let cppNamespace = "::mlir"; let cppNamespace = "::mlir::cf";
let dependentDialects = ["arith::ArithmeticDialect"]; let dependentDialects = ["arith::ArithmeticDialect"];
let hasConstantMaterializer = 1;
let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed; let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
let description = [{
This dialect contains low-level, i.e. non-region based, control flow
constructs. These constructs generally represent control flow directly
on SSA blocks of a control flow graph.
}];
} }
// Base class for Standard dialect ops. class CF_Op<string mnemonic, list<Trait> traits = []> :
class Std_Op<string mnemonic, list<Trait> traits = []> : Op<ControlFlow_Dialect, mnemonic, traits>;
Op<StandardOps_Dialect, mnemonic, traits> {
// For every standard op, there needs to be a:
// * void print(OpAsmPrinter &p, ${C++ class of Op} op)
// * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
// OperationState &result)
// functions.
let printer = [{ return ::print(p, *this); }];
let parser = [{ return ::parse$cppClass(parser, result); }];
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AssertOp // AssertOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def AssertOp : Std_Op<"assert"> { def AssertOp : CF_Op<"assert"> {
let summary = "Assert operation with message attribute"; let summary = "Assert operation with message attribute";
let description = [{ let description = [{
Assert operation with single boolean operand and an error message attribute. Assert operation with single boolean operand and an error message attribute.
If the argument is `true` this operation has no effect. Otherwise, the If the argument is `true` this operation has no effect. Otherwise, the
program execution will abort. The provided error message may be used by a program execution will abort. The provided error message may be used by a
runtime to propagate the error to the user. runtime to propagate the error to the user.
Example: Example:
```mlir ```mlir
assert %b, "Expected ... to be true" assert %b, "Expected ... to be true"
``` ```
}]; }];
let arguments = (ins I1:$arg, StrAttr:$msg); let arguments = (ins I1:$arg, StrAttr:$msg);
let assemblyFormat = "$arg `,` $msg attr-dict"; let assemblyFormat = "$arg `,` $msg attr-dict";
let hasCanonicalizeMethod = 1; let hasCanonicalizeMethod = 1;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// BranchOp // BranchOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def BranchOp : Std_Op<"br", def BranchOp : CF_Op<"br", [
[DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>, DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>,
NoSideEffect, Terminator]> { NoSideEffect, Terminator
]> {
let summary = "branch operation"; let summary = "branch operation";
let description = [{ let description = [{
The `br` operation represents a branch operation in a function. The `cf.br` operation represents a direct branch operation to a given
The operation takes variable number of operands and produces no results. block. The operands of this operation are forwarded to the successor block,
The operand number and types for each successor must match the arguments of and the number and type of the operands must match the arguments of the
the block successor. target block.
Example: Example:
```mlir ```mlir
^bb2: ^bb2:
%2 = call @someFn() %2 = call @someFn()
br ^bb3(%2 : tensor<*xf32>) cf.br ^bb3(%2 : tensor<*xf32>)
^bb3(%3: tensor<*xf32>): ^bb3(%3: tensor<*xf32>):
``` ```
}]; }];
let arguments = (ins Variadic<AnyType>:$destOperands); let arguments = (ins Variadic<AnyType>:$destOperands);
let successors = (successor AnySuccessor:$dest); let successors = (successor AnySuccessor:$dest);
let builders = [ let builders = [
OpBuilder<(ins "Block *":$dest, OpBuilder<(ins "Block *":$dest,
CArg<"ValueRange", "{}">:$destOperands), [{ CArg<"ValueRange", "{}">:$destOperands), [{
$_state.addSuccessors(dest); $_state.addSuccessors(dest);
$_state.addOperands(destOperands); $_state.addOperands(destOperands);
}]>]; }]>];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
void setDest(Block *block); void setDest(Block *block);
/// Erase the operand at 'index' from the operand list. /// Erase the operand at 'index' from the operand list.
void eraseOperand(unsigned index); void eraseOperand(unsigned index);
}]; }];
let hasCanonicalizeMethod = 1; let hasCanonicalizeMethod = 1;
let assemblyFormat = [{ let assemblyFormat = [{
$dest (`(` $destOperands^ `:` type($destOperands) `)`)? attr-dict $dest (`(` $destOperands^ `:` type($destOperands) `)`)? attr-dict
}]; }];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CallOp
//===----------------------------------------------------------------------===//
def CallOp : Std_Op<"call",
[CallOpInterface, MemRefsNormalizable,
DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
let summary = "call operation";
let description = [{
The `call` operation represents a direct call to a function that is within
the same symbol scope as the call. The operands and result types of the
call must match the specified function type. The callee is encoded as a
symbol reference attribute named "callee".
Example:
```mlir
%2 = call @my_add(%0, %1) : (f32, f32) -> f32
```
}];
let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<AnyType>:$operands);
let results = (outs Variadic<AnyType>);
let builders = [
OpBuilder<(ins "FuncOp":$callee, CArg<"ValueRange", "{}">:$operands), [{
$_state.addOperands(operands);
$_state.addAttribute("callee", SymbolRefAttr::get(callee));
$_state.addTypes(callee.getType().getResults());
}]>,
OpBuilder<(ins "SymbolRefAttr":$callee, "TypeRange":$results,
CArg<"ValueRange", "{}">:$operands), [{
$_state.addOperands(operands);
$_state.addAttribute("callee", callee);
$_state.addTypes(results);
}]>,
OpBuilder<(ins "StringAttr":$callee, "TypeRange":$results,
CArg<"ValueRange", "{}">:$operands), [{
build($_builder, $_state, SymbolRefAttr::get(callee), results, operands);
}]>,
OpBuilder<(ins "StringRef":$callee, "TypeRange":$results,
CArg<"ValueRange", "{}">:$operands), [{
build($_builder, $_state, StringAttr::get($_builder.getContext(), callee),
results, operands);
}]>];
let extraClassDeclaration = [{
FunctionType getCalleeType();
/// Get the argument operands to the called function.
operand_range getArgOperands() {
return {arg_operand_begin(), arg_operand_end()};
}
operand_iterator arg_operand_begin() { return operand_begin(); }
operand_iterator arg_operand_end() { return operand_end(); }
/// Return the callee of this operation.
CallInterfaceCallable getCallableForCallee() {
return (*this)->getAttrOfType<SymbolRefAttr>("callee");
}
}];
let assemblyFormat = [{
$callee `(` $operands `)` attr-dict `:` functional-type($operands, results)
}];
}
//===----------------------------------------------------------------------===//
// CallIndirectOp
//===----------------------------------------------------------------------===//
def CallIndirectOp : Std_Op<"call_indirect", [
CallOpInterface,
TypesMatchWith<"callee input types match argument types",
"callee", "callee_operands",
"$_self.cast<FunctionType>().getInputs()">,
TypesMatchWith<"callee result types match result types",
"callee", "results",
"$_self.cast<FunctionType>().getResults()">
]> {
let summary = "indirect call operation";
let description = [{
The `call_indirect` operation represents an indirect call to a value of
function type. Functions are first class types in MLIR, and may be passed as
arguments and merged together with block arguments. The operands and result
types of the call must match the specified function type.
Function values can be created with the
[`constant` operation](#stdconstant-constantop).
Example:
```mlir
%31 = call_indirect %15(%0, %1)
: (tensor<16xf32>, tensor<16xf32>) -> tensor<16xf32>
```
}];
let arguments = (ins FunctionType:$callee,
Variadic<AnyType>:$callee_operands);
let results = (outs Variadic<AnyType>:$results);
let builders = [
OpBuilder<(ins "Value":$callee, CArg<"ValueRange", "{}">:$operands), [{
$_state.operands.push_back(callee);
$_state.addOperands(operands);
$_state.addTypes(callee.getType().cast<FunctionType>().getResults());
}]>];
let extraClassDeclaration = [{
// TODO: Remove once migrated callers.
ValueRange operands() { return getCalleeOperands(); }
/// Get the argument operands to the called function.
operand_range getArgOperands() {
return {arg_operand_begin(), arg_operand_end()};
}
operand_iterator arg_operand_begin() { return ++operand_begin(); }
operand_iterator arg_operand_end() { return operand_end(); }
/// Return the callee of this operation.
CallInterfaceCallable getCallableForCallee() { return getCallee(); }
}];
let hasCanonicalizeMethod = 1;
let assemblyFormat =
"$callee `(` $callee_operands `)` attr-dict `:` type($callee)";
}
//===----------------------------------------------------------------------===//
// CondBranchOp // CondBranchOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def CondBranchOp : Std_Op<"cond_br", def CondBranchOp : CF_Op<"cond_br",
[AttrSizedOperandSegments, [AttrSizedOperandSegments,
DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>, DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>,
NoSideEffect, Terminator]> { NoSideEffect, Terminator]> {
let summary = "conditional branch operation"; let summary = "conditional branch operation";
let description = [{ let description = [{
The `cond_br` terminator operation represents a conditional branch on a The `cond_br` terminator operation represents a conditional branch on a
boolean (1-bit integer) value. If the bit is set, then the first destination boolean (1-bit integer) value. If the bit is set, then the first destination
is jumped to; if it is false, the second destination is chosen. The count is jumped to; if it is false, the second destination is chosen. The count
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines let assemblyFormat = [{
$condition `,` $condition `,`
$trueDest (`(` $trueDestOperands^ `:` type($trueDestOperands) `)`)? `,` $trueDest (`(` $trueDestOperands^ `:` type($trueDestOperands) `)`)? `,`
$falseDest (`(` $falseDestOperands^ `:` type($falseDestOperands) `)`)? $falseDest (`(` $falseDestOperands^ `:` type($falseDestOperands) `)`)?
attr-dict attr-dict
}]; }];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ConstantOp
//===----------------------------------------------------------------------===//
def ConstantOp : Std_Op<"constant",
[ConstantLike, NoSideEffect,
DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]> {
let summary = "constant";
let description = [{
Syntax:
```
operation ::= ssa-id `=` `std.constant` attribute-value `:` type
```
The `constant` operation produces an SSA value from a symbol reference to a
`builtin.func` operation
Example:
```mlir
// Reference to function @myfn.
%2 = constant @myfn : (tensor<16xf32>, f32) -> tensor<16xf32>
// Equivalent generic forms
%2 = "std.constant"() {value = @myfn}
: () -> ((tensor<16xf32>, f32) -> tensor<16xf32>)
```
MLIR does not allow direct references to functions in SSA operands because
the compiler is multithreaded, and disallowing SSA values to directly
reference a function simplifies this
([rationale](../Rationale/Rationale.md#multithreading-the-compiler)).
}];
let arguments = (ins FlatSymbolRefAttr:$value);
let results = (outs AnyType);
let assemblyFormat = "attr-dict $value `:` type(results)";
let extraClassDeclaration = [{
/// Returns true if a constant operation can be built with the given value
/// and result type.
static bool isBuildableWith(Attribute value, Type type);
}];
let hasFolder = 1;
let hasVerifier = 1;
}
//===----------------------------------------------------------------------===//
// ReturnOp
//===----------------------------------------------------------------------===//
def ReturnOp : Std_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
MemRefsNormalizable, ReturnLike, Terminator]> {
let summary = "return operation";
let description = [{
The `return` operation represents a return operation within a function.
The operation takes variable number of operands and produces no results.
The operand number and types must match the signature of the function
that contains the operation.
Example:
```mlir
func @foo() : (i32, f8) {
...
return %0, %1 : i32, f8
}
```
}];
let arguments = (ins Variadic<AnyType>:$operands);
let builders = [
OpBuilder<(ins),
[{ build($_builder, $_state, llvm::None); }]>];
let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
let hasVerifier = 1;
}
//===----------------------------------------------------------------------===//
// SwitchOp // SwitchOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def SwitchOp : Std_Op<"switch", def SwitchOp : CF_Op<"switch",
[AttrSizedOperandSegments, [AttrSizedOperandSegments,
DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>, DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>,
NoSideEffect, Terminator]> { NoSideEffect, Terminator]> {
let summary = "switch operation"; let summary = "switch operation";
let description = [{ let description = [{
The `switch` terminator operation represents a switch on a signless integer The `switch` terminator operation represents a switch on a signless integer
value. If the flag matches one of the specified cases, then the value. If the flag matches one of the specified cases, then the
corresponding destination is jumped to. If the flag does not match any of corresponding destination is jumped to. If the flag does not match any of
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/SCF/SCFOps.td

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines scf.for %i = 0 to 128 step %c1 {
%x = load %A[%i] : memref<128xi32> %x = load %A[%i] : memref<128xi32>
scf.yield %x : i32 scf.yield %x : i32
} }
} }
affine.for %i = 0 to 100 { affine.for %i = 0 to 100 {
"foo"() : () -> () "foo"() : () -> ()
%v = scf.execute_region -> i64 { %v = scf.execute_region -> i64 {
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
%c1 = arith.constant 1 : i64 %c1 = arith.constant 1 : i64
br ^bb3(%c1 : i64) cf.br ^bb3(%c1 : i64)
^bb2: ^bb2:
%c2 = arith.constant 2 : i64 %c2 = arith.constant 2 : i64
br ^bb3(%c2 : i64) cf.br ^bb3(%c2 : i64)
^bb3(%x : i64): ^bb3(%x : i64):
scf.yield %x : i64 scf.yield %x : i64
} }
"bar"(%v) : (i64) -> () "bar"(%v) : (i64) -> ()
} }
``` ```
}]; }];
▲ Show 20 Lines • Show All 610 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/StandardOps/IR/Ops.h

//===- Ops.h - Standard MLIR Operations -------------------------*- C++ -*-===// //===- Ops.h - Standard MLIR Operations -------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines convenience types for working with standard operations // This file defines convenience types for working with standard operations
// in the MLIR operation set. // in the MLIR operation set.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_STANDARDOPS_IR_OPS_H #ifndef MLIR_DIALECT_STANDARDOPS_IR_OPS_H
#define MLIR_DIALECT_STANDARDOPS_IR_OPS_H #define MLIR_DIALECT_STANDARDOPS_IR_OPS_H
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/IR/OpImplementation.h" #include "mlir/IR/OpImplementation.h"
#include "mlir/Interfaces/CallInterfaces.h" #include "mlir/Interfaces/CallInterfaces.h"
#include "mlir/Interfaces/CastInterfaces.h" #include "mlir/Interfaces/CastInterfaces.h"
#include "mlir/Interfaces/ControlFlowInterfaces.h" #include "mlir/Interfaces/ControlFlowInterfaces.h"
#include "mlir/Interfaces/InferTypeOpInterface.h" #include "mlir/Interfaces/InferTypeOpInterface.h"
#include "mlir/Interfaces/SideEffectInterfaces.h" #include "mlir/Interfaces/SideEffectInterfaces.h"
#include "mlir/Interfaces/VectorInterfaces.h"
// Pull in all enum type definitions and utility function declarations. // Pull in all enum type definitions and utility function declarations.
#include "mlir/Dialect/StandardOps/IR/OpsEnums.h.inc" #include "mlir/Dialect/StandardOps/IR/OpsEnums.h.inc"
namespace mlir { namespace mlir {
class AffineMap; class AffineMap;
class Builder; class Builder;
class FuncOp; class FuncOp;
Show All 10 Lines

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

  • This file was copied to mlir/include/mlir/Dialect/ControlFlow/IR/ControlFlowOps.td.
Show All 14 Lines
include "mlir/IR/OpAsmInterface.td" include "mlir/IR/OpAsmInterface.td"
include "mlir/IR/SymbolInterfaces.td" include "mlir/IR/SymbolInterfaces.td"
include "mlir/Interfaces/CallInterfaces.td" include "mlir/Interfaces/CallInterfaces.td"
include "mlir/Interfaces/CastInterfaces.td" include "mlir/Interfaces/CastInterfaces.td"
include "mlir/Interfaces/ControlFlowInterfaces.td" include "mlir/Interfaces/ControlFlowInterfaces.td"
include "mlir/Interfaces/InferTypeOpInterface.td" include "mlir/Interfaces/InferTypeOpInterface.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
include "mlir/Interfaces/VectorInterfaces.td"
def StandardOps_Dialect : Dialect { def StandardOps_Dialect : Dialect {
let name = "std"; let name = "std";
let cppNamespace = "::mlir"; let cppNamespace = "::mlir";
let dependentDialects = ["arith::ArithmeticDialect"]; let dependentDialects = ["cf::ControlFlowDialect"];
let hasConstantMaterializer = 1; let hasConstantMaterializer = 1;
let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed; let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
} }
// Base class for Standard dialect ops. // Base class for Standard dialect ops.
class Std_Op<string mnemonic, list<Trait> traits = []> : class Std_Op<string mnemonic, list<Trait> traits = []> :
Op<StandardOps_Dialect, mnemonic, traits> { Op<StandardOps_Dialect, mnemonic, traits> {
// For every standard op, there needs to be a: // For every standard op, there needs to be a:
// * void print(OpAsmPrinter &p, ${C++ class of Op} op) // * void print(OpAsmPrinter &p, ${C++ class of Op} op)
// * ParseResult parse${C++ class of Op}(OpAsmParser &parser, // * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
// OperationState &result) // OperationState &result)
// functions. // functions.
let printer = [{ return ::print(p, *this); }]; let printer = [{ return ::print(p, *this); }];
let parser = [{ return ::parse$cppClass(parser, result); }]; let parser = [{ return ::parse$cppClass(parser, result); }];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AssertOp
//===----------------------------------------------------------------------===//
def AssertOp : Std_Op<"assert"> {
let summary = "Assert operation with message attribute";
let description = [{
Assert operation with single boolean operand and an error message attribute.
If the argument is `true` this operation has no effect. Otherwise, the
program execution will abort. The provided error message may be used by a
runtime to propagate the error to the user.
Example:
```mlir
assert %b, "Expected ... to be true"
```
}];
let arguments = (ins I1:$arg, StrAttr:$msg);
let assemblyFormat = "$arg `,` $msg attr-dict";
let hasCanonicalizeMethod = 1;
}
//===----------------------------------------------------------------------===//
// BranchOp
//===----------------------------------------------------------------------===//
def BranchOp : Std_Op<"br",
[DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>,
NoSideEffect, Terminator]> {
let summary = "branch operation";
let description = [{
The `br` operation represents a branch operation in a function.
The operation takes variable number of operands and produces no results.
The operand number and types for each successor must match the arguments of
the block successor.
Example:
```mlir
^bb2:
%2 = call @someFn()
br ^bb3(%2 : tensor<*xf32>)
^bb3(%3: tensor<*xf32>):
```
}];
let arguments = (ins Variadic<AnyType>:$destOperands);
let successors = (successor AnySuccessor:$dest);
let builders = [
OpBuilder<(ins "Block *":$dest,
CArg<"ValueRange", "{}">:$destOperands), [{
$_state.addSuccessors(dest);
$_state.addOperands(destOperands);
}]>];
let extraClassDeclaration = [{
void setDest(Block *block);
/// Erase the operand at 'index' from the operand list.
void eraseOperand(unsigned index);
}];
let hasCanonicalizeMethod = 1;
let assemblyFormat = [{
$dest (`(` $destOperands^ `:` type($destOperands) `)`)? attr-dict
}];
}
//===----------------------------------------------------------------------===//
// CallOp // CallOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def CallOp : Std_Op<"call", def CallOp : Std_Op<"call",
[CallOpInterface, MemRefsNormalizable, [CallOpInterface, MemRefsNormalizable,
DeclareOpInterfaceMethods<SymbolUserOpInterface>]> { DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
let summary = "call operation"; let summary = "call operation";
let description = [{ let description = [{
▲ Show 20 Lines • Show All 116 Lines • ▼ Show 20 Linesdef CallIndirectOp : Std_Op<"call_indirect", [
let hasCanonicalizeMethod = 1; let hasCanonicalizeMethod = 1;
let assemblyFormat = let assemblyFormat =
"$callee `(` $callee_operands `)` attr-dict `:` type($callee)"; "$callee `(` $callee_operands `)` attr-dict `:` type($callee)";
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CondBranchOp
//===----------------------------------------------------------------------===//
def CondBranchOp : Std_Op<"cond_br",
[AttrSizedOperandSegments,
DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>,
NoSideEffect, Terminator]> {
let summary = "conditional branch operation";
let description = [{
The `cond_br` terminator operation represents a conditional branch on a
boolean (1-bit integer) value. If the bit is set, then the first destination
is jumped to; if it is false, the second destination is chosen. The count
and types of operands must align with the arguments in the corresponding
target blocks.
The MLIR conditional branch operation is not allowed to target the entry
block for a region. The two destinations of the conditional branch operation
are allowed to be the same.
The following example illustrates a function with a conditional branch
operation that targets the same block.
Example:
```mlir
func @select(%a: i32, %b: i32, %flag: i1) -> i32 {
// Both targets are the same, operands differ
cond_br %flag, ^bb1(%a : i32), ^bb1(%b : i32)
^bb1(%x : i32) :
return %x : i32
}
```
}];
let arguments = (ins I1:$condition,
Variadic<AnyType>:$trueDestOperands,
Variadic<AnyType>:$falseDestOperands);
let successors = (successor AnySuccessor:$trueDest, AnySuccessor:$falseDest);
let builders = [
OpBuilder<(ins "Value":$condition, "Block *":$trueDest,
"ValueRange":$trueOperands, "Block *":$falseDest,
"ValueRange":$falseOperands), [{
build($_builder, $_state, condition, trueOperands, falseOperands, trueDest,
falseDest);
}]>,
OpBuilder<(ins "Value":$condition, "Block *":$trueDest,
"Block *":$falseDest, CArg<"ValueRange", "{}">:$falseOperands), [{
build($_builder, $_state, condition, trueDest, ValueRange(), falseDest,
falseOperands);
}]>];
let extraClassDeclaration = [{
// These are the indices into the dests list.
enum { trueIndex = 0, falseIndex = 1 };
// Accessors for operands to the 'true' destination.
Value getTrueOperand(unsigned idx) {
assert(idx < getNumTrueOperands());
return getOperand(getTrueDestOperandIndex() + idx);
}
void setTrueOperand(unsigned idx, Value value) {
assert(idx < getNumTrueOperands());
setOperand(getTrueDestOperandIndex() + idx, value);
}
unsigned getNumTrueOperands() { return getTrueOperands().size(); }
/// Erase the operand at 'index' from the true operand list.
void eraseTrueOperand(unsigned index) {
getTrueDestOperandsMutable().erase(index);
}
// Accessors for operands to the 'false' destination.
Value getFalseOperand(unsigned idx) {
assert(idx < getNumFalseOperands());
return getOperand(getFalseDestOperandIndex() + idx);
}
void setFalseOperand(unsigned idx, Value value) {
assert(idx < getNumFalseOperands());
setOperand(getFalseDestOperandIndex() + idx, value);
}
operand_range getTrueOperands() { return getTrueDestOperands(); }
operand_range getFalseOperands() { return getFalseDestOperands(); }
unsigned getNumFalseOperands() { return getFalseOperands().size(); }
/// Erase the operand at 'index' from the false operand list.
void eraseFalseOperand(unsigned index) {
getFalseDestOperandsMutable().erase(index);
}
private:
/// Get the index of the first true destination operand.
unsigned getTrueDestOperandIndex() { return 1; }
/// Get the index of the first false destination operand.
unsigned getFalseDestOperandIndex() {
return getTrueDestOperandIndex() + getNumTrueOperands();
}
}];
let hasCanonicalizer = 1;
let assemblyFormat = [{
$condition `,`
$trueDest (`(` $trueDestOperands^ `:` type($trueDestOperands) `)`)? `,`
$falseDest (`(` $falseDestOperands^ `:` type($falseDestOperands) `)`)?
attr-dict
}];
}
//===----------------------------------------------------------------------===//
// ConstantOp // ConstantOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ConstantOp : Std_Op<"constant", def ConstantOp : Std_Op<"constant",
[ConstantLike, NoSideEffect, [ConstantLike, NoSideEffect,
DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]> { DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]> {
let summary = "constant"; let summary = "constant";
let description = [{ let description = [{
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Linesdef ReturnOp : Std_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
let builders = [ let builders = [
OpBuilder<(ins), OpBuilder<(ins),
[{ build($_builder, $_state, llvm::None); }]>]; [{ build($_builder, $_state, llvm::None); }]>];
let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?"; let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
let hasVerifier = 1; let hasVerifier = 1;
} }
//===----------------------------------------------------------------------===//
// SwitchOp
//===----------------------------------------------------------------------===//
def SwitchOp : Std_Op<"switch",
[AttrSizedOperandSegments,
DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>,
NoSideEffect, Terminator]> {
let summary = "switch operation";
let description = [{
The `switch` terminator operation represents a switch on a signless integer
value. If the flag matches one of the specified cases, then the
corresponding destination is jumped to. If the flag does not match any of
the cases, the default destination is jumped to. The count and types of
operands must align with the arguments in the corresponding target blocks.
Example:
```mlir
switch %flag : i32, [
default: ^bb1(%a : i32),
42: ^bb1(%b : i32),
43: ^bb3(%c : i32)
]
```
}];
let arguments = (ins
AnyInteger:$flag,
Variadic<AnyType>:$defaultOperands,
VariadicOfVariadic<AnyType, "case_operand_segments">:$caseOperands,
OptionalAttr<AnyIntElementsAttr>:$case_values,
I32ElementsAttr:$case_operand_segments
);
let successors = (successor
AnySuccessor:$defaultDestination,
VariadicSuccessor<AnySuccessor>:$caseDestinations
);
let builders = [
OpBuilder<(ins "Value":$flag,
"Block *":$defaultDestination,
"ValueRange":$defaultOperands,
CArg<"ArrayRef<APInt>", "{}">:$caseValues,
CArg<"BlockRange", "{}">:$caseDestinations,
CArg<"ArrayRef<ValueRange>", "{}">:$caseOperands)>,
OpBuilder<(ins "Value":$flag,
"Block *":$defaultDestination,
"ValueRange":$defaultOperands,
CArg<"ArrayRef<int32_t>", "{}">:$caseValues,
CArg<"BlockRange", "{}">:$caseDestinations,
CArg<"ArrayRef<ValueRange>", "{}">:$caseOperands)>,
OpBuilder<(ins "Value":$flag,
"Block *":$defaultDestination,
"ValueRange":$defaultOperands,
CArg<"DenseIntElementsAttr", "{}">:$caseValues,
CArg<"BlockRange", "{}">:$caseDestinations,
CArg<"ArrayRef<ValueRange>", "{}">:$caseOperands)>
];
let assemblyFormat = [{
$flag `:` type($flag) `,` `[` `\n`
custom<SwitchOpCases>(ref(type($flag)),$defaultDestination,
$defaultOperands,
type($defaultOperands),
$case_values,
$caseDestinations,
$caseOperands,
type($caseOperands))
`]`
attr-dict
}];
let extraClassDeclaration = [{
/// Return the operands for the case destination block at the given index.
OperandRange getCaseOperands(unsigned index) {
return getCaseOperands()[index];
}
/// Return a mutable range of operands for the case destination block at the
/// given index.
MutableOperandRange getCaseOperandsMutable(unsigned index) {
return getCaseOperandsMutable()[index];
}
}];
let hasCanonicalizer = 1;
let hasVerifier = 1;
}
#endif // STANDARD_OPS #endif // STANDARD_OPS

mlir/include/mlir/InitAllDialects.h

Show All 16 Lines
#include "mlir/Dialect/AMX/AMXDialect.h" #include "mlir/Dialect/AMX/AMXDialect.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/ArmNeon/ArmNeonDialect.h" #include "mlir/Dialect/ArmNeon/ArmNeonDialect.h"
#include "mlir/Dialect/ArmSVE/ArmSVEDialect.h" #include "mlir/Dialect/ArmSVE/ArmSVEDialect.h"
#include "mlir/Dialect/Async/IR/Async.h" #include "mlir/Dialect/Async/IR/Async.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Complex/IR/Complex.h" #include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
#include "mlir/Dialect/DLTI/DLTI.h" #include "mlir/Dialect/DLTI/DLTI.h"
#include "mlir/Dialect/EmitC/IR/EmitC.h" #include "mlir/Dialect/EmitC/IR/EmitC.h"
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/LLVMIR/NVVMDialect.h" #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
#include "mlir/Dialect/LLVMIR/ROCDLDialect.h" #include "mlir/Dialect/LLVMIR/ROCDLDialect.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
Show All 23 Linesinline void registerAllDialects(DialectRegistry &registry) {
// clang-format off // clang-format off
registry.insert<acc::OpenACCDialect, registry.insert<acc::OpenACCDialect,
AffineDialect, AffineDialect,
arith::ArithmeticDialect, arith::ArithmeticDialect,
amx::AMXDialect, amx::AMXDialect,
arm_neon::ArmNeonDialect, arm_neon::ArmNeonDialect,
async::AsyncDialect, async::AsyncDialect,
bufferization::BufferizationDialect, bufferization::BufferizationDialect,
cf::ControlFlowDialect,
complex::ComplexDialect, complex::ComplexDialect,
DLTIDialect, DLTIDialect,
emitc::EmitCDialect, emitc::EmitCDialect,
gpu::GPUDialect, gpu::GPUDialect,
LLVM::LLVMDialect, LLVM::LLVMDialect,
linalg::LinalgDialect, linalg::LinalgDialect,
math::MathDialect, math::MathDialect,
memref::MemRefDialect, memref::MemRefDialect,
Show All 31 Lines

mlir/lib/Conversion/CMakeLists.txt

add_subdirectory(AffineToStandard) add_subdirectory(AffineToStandard)
add_subdirectory(ArithmeticToLLVM) add_subdirectory(ArithmeticToLLVM)
add_subdirectory(ArithmeticToSPIRV) add_subdirectory(ArithmeticToSPIRV)
add_subdirectory(ArmNeon2dToIntr) add_subdirectory(ArmNeon2dToIntr)
add_subdirectory(AsyncToLLVM) add_subdirectory(AsyncToLLVM)
add_subdirectory(BufferizationToMemRef) add_subdirectory(BufferizationToMemRef)
add_subdirectory(ComplexToLLVM) add_subdirectory(ComplexToLLVM)
add_subdirectory(ComplexToStandard) add_subdirectory(ComplexToStandard)
add_subdirectory(ControlFlowToLLVM)
add_subdirectory(ControlFlowToSPIRV)
add_subdirectory(GPUCommon) add_subdirectory(GPUCommon)
add_subdirectory(GPUToNVVM) add_subdirectory(GPUToNVVM)
add_subdirectory(GPUToROCDL) add_subdirectory(GPUToROCDL)
add_subdirectory(GPUToSPIRV) add_subdirectory(GPUToSPIRV)
add_subdirectory(GPUToVulkan) add_subdirectory(GPUToVulkan)
add_subdirectory(LinalgToLLVM) add_subdirectory(LinalgToLLVM)
add_subdirectory(LinalgToSPIRV) add_subdirectory(LinalgToSPIRV)
add_subdirectory(LinalgToStandard) add_subdirectory(LinalgToStandard)
add_subdirectory(LLVMCommon) add_subdirectory(LLVMCommon)
add_subdirectory(MathToLibm) add_subdirectory(MathToLibm)
add_subdirectory(MathToLLVM) add_subdirectory(MathToLLVM)
add_subdirectory(MathToSPIRV) add_subdirectory(MathToSPIRV)
add_subdirectory(MemRefToLLVM) add_subdirectory(MemRefToLLVM)
add_subdirectory(MemRefToSPIRV) add_subdirectory(MemRefToSPIRV)
add_subdirectory(OpenACCToLLVM) add_subdirectory(OpenACCToLLVM)
add_subdirectory(OpenACCToSCF) add_subdirectory(OpenACCToSCF)
add_subdirectory(OpenMPToLLVM) add_subdirectory(OpenMPToLLVM)
add_subdirectory(PDLToPDLInterp) add_subdirectory(PDLToPDLInterp)
add_subdirectory(ReconcileUnrealizedCasts) add_subdirectory(ReconcileUnrealizedCasts)
add_subdirectory(SCFToControlFlow)
add_subdirectory(SCFToGPU) add_subdirectory(SCFToGPU)
add_subdirectory(SCFToOpenMP) add_subdirectory(SCFToOpenMP)
add_subdirectory(SCFToSPIRV) add_subdirectory(SCFToSPIRV)
add_subdirectory(SCFToStandard)
add_subdirectory(ShapeToStandard) add_subdirectory(ShapeToStandard)
add_subdirectory(SPIRVToLLVM) add_subdirectory(SPIRVToLLVM)
add_subdirectory(StandardToLLVM) add_subdirectory(StandardToLLVM)
add_subdirectory(StandardToSPIRV) add_subdirectory(StandardToSPIRV)
add_subdirectory(TosaToLinalg) add_subdirectory(TosaToLinalg)
add_subdirectory(TosaToSCF) add_subdirectory(TosaToSCF)
add_subdirectory(TosaToStandard) add_subdirectory(TosaToStandard)
add_subdirectory(VectorToROCDL) add_subdirectory(VectorToROCDL)
add_subdirectory(VectorToLLVM) add_subdirectory(VectorToLLVM)
add_subdirectory(VectorToGPU) add_subdirectory(VectorToGPU)
add_subdirectory(VectorToSCF) add_subdirectory(VectorToSCF)
add_subdirectory(VectorToSPIRV) add_subdirectory(VectorToSPIRV)

mlir/lib/Conversion/ControlFlowToLLVM/CMakeLists.txt

  • This file was added.
add_mlir_conversion_library(MLIRControlFlowToLLVM
ControlFlowToLLVM.cpp
ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ControlFlowToLLVM
DEPENDS
MLIRConversionPassIncGen
intrinsics_gen
LINK_COMPONENTS
Core
LINK_LIBS PUBLIC
MLIRAnalysis
MLIRControlFlow
MLIRLLVMCommonConversion
MLIRLLVMIR
MLIRPass
MLIRTransformUtils
)

mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp

  • This file was added.
//===- ControlFlowToLLVM.cpp - ControlFlow to LLVM dialect conversion -----===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements a pass to convert MLIR standard and builtin dialects
// into the LLVM IR dialect.
//
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "../PassDetail.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/LLVMCommon/VectorPattern.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Transforms/DialectConversion.h"
#include <functional>
using namespace mlir;
#define PASS_NAME "convert-cf-to-llvm"
namespace {
/// Lower `std.assert`. The default lowering calls the `abort` function if the
/// assertion is violated and has no effect otherwise. The failure message is
/// ignored by the default lowering but should be propagated by any custom
/// lowering.
struct AssertOpLowering : public ConvertOpToLLVMPattern<cf::AssertOp> {
using ConvertOpToLLVMPattern<cf::AssertOp>::ConvertOpToLLVMPattern;
LogicalResult
matchAndRewrite(cf::AssertOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
auto loc = op.getLoc();
// Insert the `abort` declaration if necessary.
auto module = op->getParentOfType<ModuleOp>();
auto abortFunc = module.lookupSymbol<LLVM::LLVMFuncOp>("abort");
if (!abortFunc) {
OpBuilder::InsertionGuard guard(rewriter);
rewriter.setInsertionPointToStart(module.getBody());
auto abortFuncTy = LLVM::LLVMFunctionType::get(getVoidType(), {});
abortFunc = rewriter.create<LLVM::LLVMFuncOp>(rewriter.getUnknownLoc(),
"abort", abortFuncTy);
}
// Split block at `assert` operation.
Block *opBlock = rewriter.getInsertionBlock();
auto opPosition = rewriter.getInsertionPoint();
Block *continuationBlock = rewriter.splitBlock(opBlock, opPosition);
// Generate IR to call `abort`.
Block *failureBlock = rewriter.createBlock(opBlock->getParent());
rewriter.create<LLVM::CallOp>(loc, abortFunc, llvm::None);
rewriter.create<LLVM::UnreachableOp>(loc);
// Generate assertion test.
rewriter.setInsertionPointToEnd(opBlock);
rewriter.replaceOpWithNewOp<LLVM::CondBrOp>(
op, adaptor.getArg(), continuationBlock, failureBlock);
return success();
}
};
// Base class for LLVM IR lowering terminator operations with successors.
template <typename SourceOp, typename TargetOp>
struct OneToOneLLVMTerminatorLowering
: public ConvertOpToLLVMPattern<SourceOp> {
using ConvertOpToLLVMPattern<SourceOp>::ConvertOpToLLVMPattern;
using Base = OneToOneLLVMTerminatorLowering<SourceOp, TargetOp>;
LogicalResult
matchAndRewrite(SourceOp op, typename SourceOp::Adaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
rewriter.replaceOpWithNewOp<TargetOp>(op, adaptor.getOperands(),
op->getSuccessors(), op->getAttrs());
return success();
}
};
// FIXME: this should be tablegen'ed as well.
struct BranchOpLowering
: public OneToOneLLVMTerminatorLowering<cf::BranchOp, LLVM::BrOp> {
using Base::Base;
};
struct CondBranchOpLowering
: public OneToOneLLVMTerminatorLowering<cf::CondBranchOp, LLVM::CondBrOp> {
using Base::Base;
};
MogballUnsubmitted
Done
ReplyInline Actions

Super or Base?

Mogball: `Super` or `Base`?
struct SwitchOpLowering
: public OneToOneLLVMTerminatorLowering<cf::SwitchOp, LLVM::SwitchOp> {
using Base::Base;
};
} // namespace
void mlir::cf::populateControlFlowToLLVMConversionPatterns(
LLVMTypeConverter &converter, RewritePatternSet &patterns) {
// clang-format off
patterns.add<
AssertOpLowering,
BranchOpLowering,
CondBranchOpLowering,
SwitchOpLowering>(converter);
// clang-format on
}
//===----------------------------------------------------------------------===//
// Pass Definition
//===----------------------------------------------------------------------===//
namespace {
/// A pass converting MLIR operations into the LLVM IR dialect.
struct ConvertControlFlowToLLVM
: public ConvertControlFlowToLLVMBase<ConvertControlFlowToLLVM> {
ConvertControlFlowToLLVM() = default;
/// Run the dialect converter on the module.
void runOnOperation() override {
LLVMConversionTarget target(getContext());
RewritePatternSet patterns(&getContext());
LowerToLLVMOptions options(&getContext());
if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout)
options.overrideIndexBitwidth(indexBitwidth);
LLVMTypeConverter converter(&getContext(), options);
mlir::cf::populateControlFlowToLLVMConversionPatterns(converter, patterns);
if (failed(applyPartialConversion(getOperation(), target,
std::move(patterns))))
signalPassFailure();
}
};
} // namespace
std::unique_ptr<Pass> mlir::cf::createConvertControlFlowToLLVMPass() {
return std::make_unique<ConvertControlFlowToLLVM>();
}

mlir/lib/Conversion/ControlFlowToSPIRV/CMakeLists.txt

  • This file was copied from mlir/lib/Conversion/StandardToSPIRV/CMakeLists.txt.
add_mlir_conversion_library(MLIRStandardToSPIRV add_mlir_conversion_library(MLIRControlFlowToSPIRV
StandardToSPIRV.cpp ControlFlowToSPIRV.cpp
StandardToSPIRVPass.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
${MLIR_MAIN_INCLUDE_DIR}/mlir/IR ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticToSPIRV
MLIRIR MLIRIR
MLIRMathToSPIRV MLIRControlFlow
MLIRMemRef
MLIRPass MLIRPass
MLIRSPIRV MLIRSPIRV
MLIRSPIRVConversion MLIRSPIRVConversion
MLIRSupport MLIRSupport
MLIRTransformUtils MLIRTransformUtils
MLIRStandard
MLIRTensor
) )

mlir/lib/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRV.cpp

  • This file was added.
//===- ControlFlowToSPIRV.cpp - ControlFlow to SPIR-V Patterns ------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements patterns to convert standard dialect to SPIR-V dialect.
//
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRV.h"
#include "../SPIRVCommon/Pattern.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
#include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
#include "mlir/IR/AffineMap.h"
#include "mlir/Support/LogicalResult.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/Support/Debug.h"
#define DEBUG_TYPE "cf-to-spirv-pattern"
using namespace mlir;
//===----------------------------------------------------------------------===//
// Operation conversion
//===----------------------------------------------------------------------===//
namespace {
/// Converts cf.br to spv.Branch.
struct BranchOpPattern final : public OpConversionPattern<cf::BranchOp> {
using OpConversionPattern<cf::BranchOp>::OpConversionPattern;
LogicalResult
matchAndRewrite(cf::BranchOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
rewriter.replaceOpWithNewOp<spirv::BranchOp>(op, op.getDest(),
adaptor.getDestOperands());
return success();
}
};
/// Converts cf.cond_br to spv.BranchConditional.
struct CondBranchOpPattern final
: public OpConversionPattern<cf::CondBranchOp> {
using OpConversionPattern<cf::CondBranchOp>::OpConversionPattern;
LogicalResult
matchAndRewrite(cf::CondBranchOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
rewriter.replaceOpWithNewOp<spirv::BranchConditionalOp>(
op, op.getCondition(), op.getTrueDest(), adaptor.getTrueDestOperands(),
op.getFalseDest(), adaptor.getFalseDestOperands());
return success();
}
};
} // namespace
//===----------------------------------------------------------------------===//
// Pattern population
//===----------------------------------------------------------------------===//
void mlir::cf::populateControlFlowToSPIRVPatterns(
SPIRVTypeConverter &typeConverter, RewritePatternSet &patterns) {
MLIRContext *context = patterns.getContext();
patterns.add<BranchOpPattern, CondBranchOpPattern>(typeConverter, context);
}

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

//===- LowerGpuOpsToNVVMOps.cpp - MLIR GPU to NVVM lowering passes --------===// //===- LowerGpuOpsToNVVMOps.cpp - MLIR GPU to NVVM lowering passes --------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to generate NVVMIR operations for higher-level // This file implements a pass to generate NVVMIR operations for higher-level
// GPU operations. // GPU operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h" #include "mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/LoweringOptions.h" #include "mlir/Conversion/LLVMCommon/LoweringOptions.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.h"
#include "mlir/Dialect/GPU/Passes.h" #include "mlir/Dialect/GPU/Passes.h"
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines void runOnOperation() override {
RewritePatternSet llvmPatterns(m.getContext()); RewritePatternSet llvmPatterns(m.getContext());
// Apply in-dialect lowering first. In-dialect lowering will replace ops // Apply in-dialect lowering first. In-dialect lowering will replace ops
// which need to be lowered further, which is not supported by a single // which need to be lowered further, which is not supported by a single
// conversion pass. // conversion pass.
populateGpuRewritePatterns(patterns); populateGpuRewritePatterns(patterns);
(void)applyPatternsAndFoldGreedily(m, std::move(patterns)); (void)applyPatternsAndFoldGreedily(m, std::move(patterns));
mlir::arith::populateArithmeticToLLVMConversionPatterns(converter, arith::populateArithmeticToLLVMConversionPatterns(converter, llvmPatterns);
llvmPatterns); cf::populateControlFlowToLLVMConversionPatterns(converter, llvmPatterns);
populateStdToLLVMConversionPatterns(converter, llvmPatterns); populateStdToLLVMConversionPatterns(converter, llvmPatterns);
populateMemRefToLLVMConversionPatterns(converter, llvmPatterns); populateMemRefToLLVMConversionPatterns(converter, llvmPatterns);
populateGpuToNVVMConversionPatterns(converter, llvmPatterns); populateGpuToNVVMConversionPatterns(converter, llvmPatterns);
populateGpuWMMAToNVVMConversionPatterns(converter, llvmPatterns); populateGpuWMMAToNVVMConversionPatterns(converter, llvmPatterns);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
configureGpuToNVVMConversionLegality(target); configureGpuToNVVMConversionLegality(target);
if (failed(applyPartialConversion(m, target, std::move(llvmPatterns)))) if (failed(applyPartialConversion(m, target, std::move(llvmPatterns))))
signalPassFailure(); signalPassFailure();
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

mlir/lib/Conversion/LinalgToLLVM/CMakeLists.txt

Show All 13 Linesadd_mlir_conversion_library(MLIRLinalgToLLVM
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffineToStandard MLIRAffineToStandard
MLIRIR MLIRIR
MLIRLinalg MLIRLinalg
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMIR MLIRLLVMIR
MLIRMemRefToLLVM MLIRMemRefToLLVM
MLIRSCFToStandard MLIRSCFToControlFlow
MLIRTransforms MLIRTransforms
MLIRVectorToLLVM MLIRVectorToLLVM
MLIRVectorToSCF MLIRVectorToSCF
) )

mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp

//===- LinalgToLLVM.cpp - conversion from Linalg to LLVM dialect ----------===// //===- LinalgToLLVM.cpp - conversion from Linalg to LLVM dialect ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h" #include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h" #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/SCFToStandard/SCFToStandard.h" #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h" #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
#include "mlir/Conversion/VectorToSCF/VectorToSCF.h" #include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

Show First 20 Lines • Show All 427 Lines • ▼ Show 20 Lines
}; };
/// Wrap a llvm.cmpxchg operation in a while loop so that the operation can be /// Wrap a llvm.cmpxchg operation in a while loop so that the operation can be
/// retried until it succeeds in atomically storing a new value into memory. /// retried until it succeeds in atomically storing a new value into memory.
/// ///
/// +---------------------------------+ /// +---------------------------------+
/// | <code before the AtomicRMWOp> | /// | <code before the AtomicRMWOp> |
/// | <compute initial %loaded> | /// | <compute initial %loaded> |
/// | br loop(%loaded) | /// | cf.br loop(%loaded) |
/// +---------------------------------+ /// +---------------------------------+
/// | /// |
/// -------| | /// -------| |
/// | v v /// | v v
/// | +--------------------------------+ /// | +--------------------------------+
/// | | loop(%loaded): | /// | | loop(%loaded): |
/// | | <body contents> | /// | | <body contents> |
/// | | %pair = cmpxchg | /// | | %pair = cmpxchg |
/// | | %ok = %pair[0] | /// | | %ok = %pair[0] |
/// | | %new = %pair[1] | /// | | %new = %pair[1] |
/// | | cond_br %ok, end, loop(%new) | /// | | cf.cond_br %ok, end, loop(%new) |
/// | +--------------------------------+ /// | +--------------------------------+
/// | | | /// | | |
/// |----------- | /// |----------- |
/// v /// v
/// +--------------------------------+ /// +--------------------------------+
/// | end: | /// | end: |
/// | <code after the AtomicRMWOp> | /// | <code after the AtomicRMWOp> |
/// +--------------------------------+ /// +--------------------------------+
▲ Show 20 Lines • Show All 1,403 Lines • Show Last 20 Lines

mlir/lib/Conversion/OpenMPToLLVM/OpenMPToLLVM.cpp

//===- OpenMPToLLVM.cpp - conversion from OpenMP to LLVM dialect ----------===// //===- OpenMPToLLVM.cpp - conversion from OpenMP to LLVM dialect ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h" #include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h"
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/OpenMP/OpenMPDialect.h" #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
Show All 40 Lines
} // namespace } // namespace
void ConvertOpenMPToLLVMPass::runOnOperation() { void ConvertOpenMPToLLVMPass::runOnOperation() {
auto module = getOperation(); auto module = getOperation();
// Convert to OpenMP operations with LLVM IR dialect // Convert to OpenMP operations with LLVM IR dialect
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
LLVMTypeConverter converter(&getContext()); LLVMTypeConverter converter(&getContext());
mlir::arith::populateArithmeticToLLVMConversionPatterns(converter, patterns); arith::populateArithmeticToLLVMConversionPatterns(converter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(converter, patterns);
populateMemRefToLLVMConversionPatterns(converter, patterns); populateMemRefToLLVMConversionPatterns(converter, patterns);
populateStdToLLVMConversionPatterns(converter, patterns); populateStdToLLVMConversionPatterns(converter, patterns);
populateOpenMPToLLVMConversionPatterns(converter, patterns); populateOpenMPToLLVMConversionPatterns(converter, patterns);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
target.addDynamicallyLegalOp<omp::MasterOp, omp::ParallelOp, omp::WsLoopOp>( target.addDynamicallyLegalOp<omp::MasterOp, omp::ParallelOp, omp::WsLoopOp>(
[&](Operation *op) { return converter.isLegal(&op->getRegion(0)); }); [&](Operation *op) { return converter.isLegal(&op->getRegion(0)); });
target.addLegalOp<omp::TerminatorOp, omp::TaskyieldOp, omp::FlushOp, target.addLegalOp<omp::TerminatorOp, omp::TaskyieldOp, omp::FlushOp,
omp::BarrierOp, omp::TaskwaitOp>(); omp::BarrierOp, omp::TaskwaitOp>();
if (failed(applyPartialConversion(module, target, std::move(patterns)))) if (failed(applyPartialConversion(module, target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertOpenMPToLLVMPass() { std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertOpenMPToLLVMPass() {
return std::make_unique<ConvertOpenMPToLLVMPass>(); return std::make_unique<ConvertOpenMPToLLVMPass>();
} }

mlir/lib/Conversion/PassDetail.h

Show All 23 Lines
namespace acc { namespace acc {
class OpenACCDialect; class OpenACCDialect;
} // namespace acc } // namespace acc
namespace arith { namespace arith {
class ArithmeticDialect; class ArithmeticDialect;
} // namespace arith } // namespace arith
namespace cf {
class ControlFlowDialect;
} // namespace cf
namespace complex { namespace complex {
class ComplexDialect; class ComplexDialect;
} // namespace complex } // namespace complex
namespace gpu { namespace gpu {
class GPUDialect; class GPUDialect;
class GPUModuleOp; class GPUModuleOp;
} // namespace gpu } // namespace gpu
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

mlir/lib/Conversion/SCFToControlFlow/CMakeLists.txt

  • This file was moved from mlir/lib/Conversion/SCFToStandard/CMakeLists.txt.
add_mlir_conversion_library(MLIRSCFToStandard add_mlir_conversion_library(MLIRSCFToControlFlow
SCFToStandard.cpp SCFToControlFlow.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SCFToStandard ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SCFToControlFlow
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmetic MLIRArithmetic
MLIRControlFlow
MLIRSCF MLIRSCF
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/SCFToControlFlow/SCFToControlFlow.cpp

  • This file was moved from mlir/lib/Conversion/SCFToStandard/SCFToStandard.cpp.
//===- SCFToStandard.cpp - ControlFlow to CFG conversion ------------------===// //===- SCFToControlFlow.cpp - SCF to CF conversion ------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to convert scf.for, scf.if and loop.terminator // This file implements a pass to convert scf.for, scf.if and loop.terminator
// ops into standard CFG ops. // ops into standard CFG ops.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/SCFToStandard/SCFToStandard.h" #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/MLIRContext.h" #include "mlir/IR/MLIRContext.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/Passes.h" #include "mlir/Transforms/Passes.h"
using namespace mlir; using namespace mlir;
using namespace mlir::scf; using namespace mlir::scf;
namespace { namespace {
struct SCFToStandardPass : public SCFToStandardBase<SCFToStandardPass> { struct SCFToControlFlowPass
: public SCFToControlFlowBase<SCFToControlFlowPass> {
void runOnOperation() override; void runOnOperation() override;
}; };
// Create a CFG subgraph for the loop around its body blocks (if the body // Create a CFG subgraph for the loop around its body blocks (if the body
// contained other loops, they have been already lowered to a flow of blocks). // contained other loops, they have been already lowered to a flow of blocks).
// Maintain the invariants that a CFG subgraph created for any loop has a single // Maintain the invariants that a CFG subgraph created for any loop has a single
// entry and a single exit, and that the entry/exit blocks are respectively // entry and a single exit, and that the entry/exit blocks are respectively
// first/last blocks in the parent region. The original loop operation is // first/last blocks in the parent region. The original loop operation is
Show All 11 Lines
// invariant we maintain) along with a branch that loops back to the condition // invariant we maintain) along with a branch that loops back to the condition
// block. Loop-carried values are the loop terminator operands, which are // block. Loop-carried values are the loop terminator operands, which are
// forwarded to the branch. // forwarded to the branch.
// //
// +---------------------------------+ // +---------------------------------+
// | <code before the ForOp> | // | <code before the ForOp> |
// | <definitions of %init...> | // | <definitions of %init...> |
// | <compute initial %iv value> | // | <compute initial %iv value> |
// | br cond(%iv, %init...) | // | cf.br cond(%iv, %init...) |
// +---------------------------------+ // +---------------------------------+
// | // |
// -------| | // -------| |
// | v v // | v v
// | +--------------------------------+ // | +--------------------------------+
// | | cond(%iv, %init...): | // | | cond(%iv, %init...): |
// | | <compare %iv to upper bound> | // | | <compare %iv to upper bound> |
// | | cond_br %r, body, end | // | | cf.cond_br %r, body, end |
// | +--------------------------------+ // | +--------------------------------+
// | | | // | | |
// | | -------------| // | | -------------|
// | v | // | v |
// | +--------------------------------+ | // | +--------------------------------+ |
// | | body-first: | | // | | body-first: | |
// | | <%init visible by dominance> | | // | | <%init visible by dominance> | |
// | | <body contents> | | // | | <body contents> | |
// | +--------------------------------+ | // | +--------------------------------+ |
// | | | // | | |
// | ... | // | ... |
// | | | // | | |
// | +--------------------------------+ | // | +--------------------------------+ |
// | | body-last: | | // | | body-last: | |
// | | <body contents> | | // | | <body contents> | |
// | | <operands of yield = %yields>| | // | | <operands of yield = %yields>| |
// | | %new_iv =<add step to %iv> | | // | | %new_iv =<add step to %iv> | |
// | | br cond(%new_iv, %yields) | | // | | cf.br cond(%new_iv, %yields) | |
// | +--------------------------------+ | // | +--------------------------------+ |
// | | | // | | |
// |----------- |-------------------- // |----------- |--------------------
// v // v
// +--------------------------------+ // +--------------------------------+
// | end: | // | end: |
// | <code after the ForOp> | // | <code after the ForOp> |
// | <%init visible by dominance> | // | <%init visible by dominance> |
Show All 25 Lines
// block, which is illegal in a conversion pattern). When the "else" region is // block, which is illegal in a conversion pattern). When the "else" region is
// empty, which is only allowed for "scf.if"s that don't return values, the // empty, which is only allowed for "scf.if"s that don't return values, the
// condition branches directly to the continuation block. // condition branches directly to the continuation block.
// //
// CFG for a scf.if with else and without results. // CFG for a scf.if with else and without results.
// //
// +--------------------------------+ // +--------------------------------+
// | <code before the IfOp> | // | <code before the IfOp> |
// | cond_br %cond, %then, %else | // | cf.cond_br %cond, %then, %else |
// +--------------------------------+ // +--------------------------------+
// | | // | |
// | --------------| // | --------------|
// v | // v |
// +--------------------------------+ | // +--------------------------------+ |
// | then: | | // | then: | |
// | <then contents> | | // | <then contents> | |
// | br continue | | // | cf.br continue | |
// +--------------------------------+ | // +--------------------------------+ |
// | | // | |
// |---------- |------------- // |---------- |-------------
// | V // | V
// | +--------------------------------+ // | +--------------------------------+
// | | else: | // | | else: |
// | | <else contents> | // | | <else contents> |
// | | br continue | // | | cf.br continue |
// | +--------------------------------+ // | +--------------------------------+
// | | // | |
// ------| | // ------| |
// v v // v v
// +--------------------------------+ // +--------------------------------+
// | continue: | // | continue: |
// | <code after the IfOp> | // | <code after the IfOp> |
// +--------------------------------+ // +--------------------------------+
// //
// CFG for a scf.if with results. // CFG for a scf.if with results.
// //
// +--------------------------------+ // +--------------------------------+
// | <code before the IfOp> | // | <code before the IfOp> |
// | cond_br %cond, %then, %else | // | cf.cond_br %cond, %then, %else |
// +--------------------------------+ // +--------------------------------+
// | | // | |
// | --------------| // | --------------|
// v | // v |
// +--------------------------------+ | // +--------------------------------+ |
// | then: | | // | then: | |
// | <then contents> | | // | <then contents> | |
// | br dom(%args...) | | // | cf.br dom(%args...) | |
// +--------------------------------+ | // +--------------------------------+ |
// | | // | |
// |---------- |------------- // |---------- |-------------
// | V // | V
// | +--------------------------------+ // | +--------------------------------+
// | | else: | // | | else: |
// | | <else contents> | // | | <else contents> |
// | | br dom(%args...) | // | | cf.br dom(%args...) |
// | +--------------------------------+ // | +--------------------------------+
// | | // | |
// ------| | // ------| |
// v v // v v
// +--------------------------------+ // +--------------------------------+
// | dom(%args...): | // | dom(%args...): |
// | br continue | // | cf.br continue |
// +--------------------------------+ // +--------------------------------+
// | // |
// v // v
// +--------------------------------+ // +--------------------------------+
// | continue: | // | continue: |
// | <code after the IfOp> | // | <code after the IfOp> |
// +--------------------------------+ // +--------------------------------+
// //
Show All 23 Lines
/// they contain have been already converted to CFG), but need to be single-exit /// they contain have been already converted to CFG), but need to be single-exit
/// from the last block of each region. The operations following the original /// from the last block of each region. The operations following the original
/// WhileOp are split into a new continuation block. Both regions of the WhileOp /// WhileOp are split into a new continuation block. Both regions of the WhileOp
/// are inlined, and their terminators are rewritten to organize the control /// are inlined, and their terminators are rewritten to organize the control
/// flow implementing the loop as follows. /// flow implementing the loop as follows.
/// ///
/// +---------------------------------+ /// +---------------------------------+
/// | <code before the WhileOp> | /// | <code before the WhileOp> |
/// | br ^before(%operands...) | /// | cf.br ^before(%operands...) |
/// +---------------------------------+ /// +---------------------------------+
/// | /// |
/// -------| | /// -------| |
/// | v v /// | v v
/// | +--------------------------------+ /// | +--------------------------------+
/// | | ^before(%bargs...): | /// | | ^before(%bargs...): |
/// | | %vals... = <some payload> | /// | | %vals... = <some payload> |
/// | +--------------------------------+ /// | +--------------------------------+
/// | | /// | |
/// | ... /// | ...
/// | | /// | |
/// | +--------------------------------+ /// | +--------------------------------+
/// | | ^before-last: /// | | ^before-last:
/// | | %cond = <compute condition> | /// | | %cond = <compute condition> |
/// | | cond_br %cond, | /// | | cf.cond_br %cond, |
/// | | ^after(%vals...), ^cont | /// | | ^after(%vals...), ^cont |
/// | +--------------------------------+ /// | +--------------------------------+
/// | | | /// | | |
/// | | -------------| /// | | -------------|
/// | v | /// | v |
/// | +--------------------------------+ | /// | +--------------------------------+ |
/// | | ^after(%aargs...): | | /// | | ^after(%aargs...): | |
/// | | <body contents> | | /// | | <body contents> | |
/// | +--------------------------------+ | /// | +--------------------------------+ |
/// | | | /// | | |
/// | ... | /// | ... |
/// | | | /// | | |
/// | +--------------------------------+ | /// | +--------------------------------+ |
/// | | ^after-last: | | /// | | ^after-last: | |
/// | | %yields... = <some payload> | | /// | | %yields... = <some payload> | |
/// | | br ^before(%yields...) | | /// | | cf.br ^before(%yields...) | |
/// | +--------------------------------+ | /// | +--------------------------------+ |
/// | | | /// | | |
/// |----------- |-------------------- /// |----------- |--------------------
/// v /// v
/// +--------------------------------+ /// +--------------------------------+
/// | ^cont: | /// | ^cont: |
/// | <code after the WhileOp> | /// | <code after the WhileOp> |
/// | <%vals from 'before' region | /// | <%vals from 'before' region |
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 LinesLogicalResult ForLowering::matchAndRewrite(ForOp forOp,
auto step = forOp.getStep(); auto step = forOp.getStep();
auto stepped = rewriter.create<arith::AddIOp>(loc, iv, step).getResult(); auto stepped = rewriter.create<arith::AddIOp>(loc, iv, step).getResult();
if (!stepped) if (!stepped)
return failure(); return failure();
SmallVector<Value, 8> loopCarried; SmallVector<Value, 8> loopCarried;
loopCarried.push_back(stepped); loopCarried.push_back(stepped);
loopCarried.append(terminator->operand_begin(), terminator->operand_end()); loopCarried.append(terminator->operand_begin(), terminator->operand_end());
rewriter.create<BranchOp>(loc, conditionBlock, loopCarried); rewriter.create<cf::BranchOp>(loc, conditionBlock, loopCarried);
rewriter.eraseOp(terminator); rewriter.eraseOp(terminator);
// Compute loop bounds before branching to the condition. // Compute loop bounds before branching to the condition.
rewriter.setInsertionPointToEnd(initBlock); rewriter.setInsertionPointToEnd(initBlock);
Value lowerBound = forOp.getLowerBound(); Value lowerBound = forOp.getLowerBound();
Value upperBound = forOp.getUpperBound(); Value upperBound = forOp.getUpperBound();
if (!lowerBound || !upperBound) if (!lowerBound || !upperBound)
return failure(); return failure();
// The initial values of loop-carried values is obtained from the operands // The initial values of loop-carried values is obtained from the operands
// of the loop operation. // of the loop operation.
SmallVector<Value, 8> destOperands; SmallVector<Value, 8> destOperands;
destOperands.push_back(lowerBound); destOperands.push_back(lowerBound);
auto iterOperands = forOp.getIterOperands(); auto iterOperands = forOp.getIterOperands();
destOperands.append(iterOperands.begin(), iterOperands.end()); destOperands.append(iterOperands.begin(), iterOperands.end());
rewriter.create<BranchOp>(loc, conditionBlock, destOperands); rewriter.create<cf::BranchOp>(loc, conditionBlock, destOperands);
// With the body block done, we can fill in the condition block. // With the body block done, we can fill in the condition block.
rewriter.setInsertionPointToEnd(conditionBlock); rewriter.setInsertionPointToEnd(conditionBlock);
auto comparison = rewriter.create<arith::CmpIOp>( auto comparison = rewriter.create<arith::CmpIOp>(
loc, arith::CmpIPredicate::slt, iv, upperBound); loc, arith::CmpIPredicate::slt, iv, upperBound);
rewriter.create<CondBranchOp>(loc, comparison, firstBodyBlock, rewriter.create<cf::CondBranchOp>(loc, comparison, firstBodyBlock,
ArrayRef<Value>(), endBlock, ArrayRef<Value>()); ArrayRef<Value>(), endBlock,
ArrayRef<Value>());
// The result of the loop operation is the values of the condition block // The result of the loop operation is the values of the condition block
// arguments except the induction variable on the last iteration. // arguments except the induction variable on the last iteration.
rewriter.replaceOp(forOp, conditionBlock->getArguments().drop_front()); rewriter.replaceOp(forOp, conditionBlock->getArguments().drop_front());
return success(); return success();
} }
LogicalResult IfLowering::matchAndRewrite(IfOp ifOp, LogicalResult IfLowering::matchAndRewrite(IfOp ifOp,
PatternRewriter &rewriter) const { PatternRewriter &rewriter) const {
auto loc = ifOp.getLoc(); auto loc = ifOp.getLoc();
// Start by splitting the block containing the 'scf.if' into two parts. // Start by splitting the block containing the 'scf.if' into two parts.
// The part before will contain the condition, the part after will be the // The part before will contain the condition, the part after will be the
// continuation point. // continuation point.
auto *condBlock = rewriter.getInsertionBlock(); auto *condBlock = rewriter.getInsertionBlock();
auto opPosition = rewriter.getInsertionPoint(); auto opPosition = rewriter.getInsertionPoint();
auto *remainingOpsBlock = rewriter.splitBlock(condBlock, opPosition); auto *remainingOpsBlock = rewriter.splitBlock(condBlock, opPosition);
Block *continueBlock; Block *continueBlock;
if (ifOp.getNumResults() == 0) { if (ifOp.getNumResults() == 0) {
continueBlock = remainingOpsBlock; continueBlock = remainingOpsBlock;
} else { } else {
continueBlock = continueBlock =
rewriter.createBlock(remainingOpsBlock, ifOp.getResultTypes(), rewriter.createBlock(remainingOpsBlock, ifOp.getResultTypes(),
SmallVector<Location>(ifOp.getNumResults(), loc)); SmallVector<Location>(ifOp.getNumResults(), loc));
rewriter.create<BranchOp>(loc, remainingOpsBlock); rewriter.create<cf::BranchOp>(loc, remainingOpsBlock);
} }
// Move blocks from the "then" region to the region containing 'scf.if', // Move blocks from the "then" region to the region containing 'scf.if',
// place it before the continuation block, and branch to it. // place it before the continuation block, and branch to it.
auto &thenRegion = ifOp.getThenRegion(); auto &thenRegion = ifOp.getThenRegion();
auto *thenBlock = &thenRegion.front(); auto *thenBlock = &thenRegion.front();
Operation *thenTerminator = thenRegion.back().getTerminator(); Operation *thenTerminator = thenRegion.back().getTerminator();
ValueRange thenTerminatorOperands = thenTerminator->getOperands(); ValueRange thenTerminatorOperands = thenTerminator->getOperands();
rewriter.setInsertionPointToEnd(&thenRegion.back()); rewriter.setInsertionPointToEnd(&thenRegion.back());
rewriter.create<BranchOp>(loc, continueBlock, thenTerminatorOperands); rewriter.create<cf::BranchOp>(loc, continueBlock, thenTerminatorOperands);
rewriter.eraseOp(thenTerminator); rewriter.eraseOp(thenTerminator);
rewriter.inlineRegionBefore(thenRegion, continueBlock); rewriter.inlineRegionBefore(thenRegion, continueBlock);
// Move blocks from the "else" region (if present) to the region containing // Move blocks from the "else" region (if present) to the region containing
// 'scf.if', place it before the continuation block and branch to it. It // 'scf.if', place it before the continuation block and branch to it. It
// will be placed after the "then" regions. // will be placed after the "then" regions.
auto *elseBlock = continueBlock; auto *elseBlock = continueBlock;
auto &elseRegion = ifOp.getElseRegion(); auto &elseRegion = ifOp.getElseRegion();
if (!elseRegion.empty()) { if (!elseRegion.empty()) {
elseBlock = &elseRegion.front(); elseBlock = &elseRegion.front();
Operation *elseTerminator = elseRegion.back().getTerminator(); Operation *elseTerminator = elseRegion.back().getTerminator();
ValueRange elseTerminatorOperands = elseTerminator->getOperands(); ValueRange elseTerminatorOperands = elseTerminator->getOperands();
rewriter.setInsertionPointToEnd(&elseRegion.back()); rewriter.setInsertionPointToEnd(&elseRegion.back());
rewriter.create<BranchOp>(loc, continueBlock, elseTerminatorOperands); rewriter.create<cf::BranchOp>(loc, continueBlock, elseTerminatorOperands);
rewriter.eraseOp(elseTerminator); rewriter.eraseOp(elseTerminator);
rewriter.inlineRegionBefore(elseRegion, continueBlock); rewriter.inlineRegionBefore(elseRegion, continueBlock);
} }
rewriter.setInsertionPointToEnd(condBlock); rewriter.setInsertionPointToEnd(condBlock);
rewriter.create<CondBranchOp>(loc, ifOp.getCondition(), thenBlock, rewriter.create<cf::CondBranchOp>(loc, ifOp.getCondition(), thenBlock,
/*trueArgs=*/ArrayRef<Value>(), elseBlock, /*trueArgs=*/ArrayRef<Value>(), elseBlock,
/*falseArgs=*/ArrayRef<Value>()); /*falseArgs=*/ArrayRef<Value>());
// Ok, we're done! // Ok, we're done!
rewriter.replaceOp(ifOp, continueBlock->getArguments()); rewriter.replaceOp(ifOp, continueBlock->getArguments());
return success(); return success();
} }
LogicalResult LogicalResult
ExecuteRegionLowering::matchAndRewrite(ExecuteRegionOp op, ExecuteRegionLowering::matchAndRewrite(ExecuteRegionOp op,
PatternRewriter &rewriter) const { PatternRewriter &rewriter) const {
auto loc = op.getLoc(); auto loc = op.getLoc();
auto *condBlock = rewriter.getInsertionBlock(); auto *condBlock = rewriter.getInsertionBlock();
auto opPosition = rewriter.getInsertionPoint(); auto opPosition = rewriter.getInsertionPoint();
auto *remainingOpsBlock = rewriter.splitBlock(condBlock, opPosition); auto *remainingOpsBlock = rewriter.splitBlock(condBlock, opPosition);
auto &region = op.getRegion(); auto &region = op.getRegion();
rewriter.setInsertionPointToEnd(condBlock); rewriter.setInsertionPointToEnd(condBlock);
rewriter.create<BranchOp>(loc, &region.front()); rewriter.create<cf::BranchOp>(loc, &region.front());
for (Block &block : region) { for (Block &block : region) {
if (auto terminator = dyn_cast<scf::YieldOp>(block.getTerminator())) { if (auto terminator = dyn_cast<scf::YieldOp>(block.getTerminator())) {
ValueRange terminatorOperands = terminator->getOperands(); ValueRange terminatorOperands = terminator->getOperands();
rewriter.setInsertionPointToEnd(&block); rewriter.setInsertionPointToEnd(&block);
rewriter.create<BranchOp>(loc, remainingOpsBlock, terminatorOperands); rewriter.create<cf::BranchOp>(loc, remainingOpsBlock, terminatorOperands);
rewriter.eraseOp(terminator); rewriter.eraseOp(terminator);
} }
} }
rewriter.inlineRegionBefore(region, remainingOpsBlock); rewriter.inlineRegionBefore(region, remainingOpsBlock);
SmallVector<Value> vals; SmallVector<Value> vals;
SmallVector<Location> argLocs(op.getNumResults(), op->getLoc()); SmallVector<Location> argLocs(op.getNumResults(), op->getLoc());
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 LinesLogicalResult WhileLowering::matchAndRewrite(WhileOp whileOp,
Block *afterLast = &whileOp.getAfter().back(); Block *afterLast = &whileOp.getAfter().back();
Block *before = &whileOp.getBefore().front(); Block *before = &whileOp.getBefore().front();
Block *beforeLast = &whileOp.getBefore().back(); Block *beforeLast = &whileOp.getBefore().back();
rewriter.inlineRegionBefore(whileOp.getAfter(), continuation); rewriter.inlineRegionBefore(whileOp.getAfter(), continuation);
rewriter.inlineRegionBefore(whileOp.getBefore(), after); rewriter.inlineRegionBefore(whileOp.getBefore(), after);
// Branch to the "before" region. // Branch to the "before" region.
rewriter.setInsertionPointToEnd(currentBlock); rewriter.setInsertionPointToEnd(currentBlock);
rewriter.create<BranchOp>(loc, before, whileOp.getInits()); rewriter.create<cf::BranchOp>(loc, before, whileOp.getInits());
// Replace terminators with branches. Assuming bodies are SESE, which holds // Replace terminators with branches. Assuming bodies are SESE, which holds
// given only the patterns from this file, we only need to look at the last // given only the patterns from this file, we only need to look at the last
// block. This should be reconsidered if we allow break/continue in SCF. // block. This should be reconsidered if we allow break/continue in SCF.
rewriter.setInsertionPointToEnd(beforeLast); rewriter.setInsertionPointToEnd(beforeLast);
auto condOp = cast<ConditionOp>(beforeLast->getTerminator()); auto condOp = cast<ConditionOp>(beforeLast->getTerminator());
rewriter.replaceOpWithNewOp<CondBranchOp>(condOp, condOp.getCondition(), rewriter.replaceOpWithNewOp<cf::CondBranchOp>(condOp, condOp.getCondition(),
after, condOp.getArgs(), after, condOp.getArgs(),
continuation, ValueRange()); continuation, ValueRange());
rewriter.setInsertionPointToEnd(afterLast); rewriter.setInsertionPointToEnd(afterLast);
auto yieldOp = cast<scf::YieldOp>(afterLast->getTerminator()); auto yieldOp = cast<scf::YieldOp>(afterLast->getTerminator());
rewriter.replaceOpWithNewOp<BranchOp>(yieldOp, before, yieldOp.getResults()); rewriter.replaceOpWithNewOp<cf::BranchOp>(yieldOp, before,
yieldOp.getResults());
// Replace the op with values "yielded" from the "before" region, which are // Replace the op with values "yielded" from the "before" region, which are
// visible by dominance. // visible by dominance.
rewriter.replaceOp(whileOp, condOp.getArgs()); rewriter.replaceOp(whileOp, condOp.getArgs());
return success(); return success();
} }
Show All 25 LinesDoWhileLowering::matchAndRewrite(WhileOp whileOp,
// Only the "before" region should be inlined. // Only the "before" region should be inlined.
Block *before = &whileOp.getBefore().front(); Block *before = &whileOp.getBefore().front();
Block *beforeLast = &whileOp.getBefore().back(); Block *beforeLast = &whileOp.getBefore().back();
rewriter.inlineRegionBefore(whileOp.getBefore(), continuation); rewriter.inlineRegionBefore(whileOp.getBefore(), continuation);
// Branch to the "before" region. // Branch to the "before" region.
rewriter.setInsertionPointToEnd(currentBlock); rewriter.setInsertionPointToEnd(currentBlock);
rewriter.create<BranchOp>(whileOp.getLoc(), before, whileOp.getInits()); rewriter.create<cf::BranchOp>(whileOp.getLoc(), before, whileOp.getInits());
// Loop around the "before" region based on condition. // Loop around the "before" region based on condition.
rewriter.setInsertionPointToEnd(beforeLast); rewriter.setInsertionPointToEnd(beforeLast);
auto condOp = cast<ConditionOp>(beforeLast->getTerminator()); auto condOp = cast<ConditionOp>(beforeLast->getTerminator());
rewriter.replaceOpWithNewOp<CondBranchOp>(condOp, condOp.getCondition(), rewriter.replaceOpWithNewOp<cf::CondBranchOp>(condOp, condOp.getCondition(),
before, condOp.getArgs(), before, condOp.getArgs(),
continuation, ValueRange()); continuation, ValueRange());
// Replace the op with values "yielded" from the "before" region, which are // Replace the op with values "yielded" from the "before" region, which are
// visible by dominance. // visible by dominance.
rewriter.replaceOp(whileOp, condOp.getArgs()); rewriter.replaceOp(whileOp, condOp.getArgs());
return success(); return success();
} }
void mlir::populateLoopToStdConversionPatterns(RewritePatternSet &patterns) { void mlir::populateSCFToControlFlowConversionPatterns(
RewritePatternSet &patterns) {
patterns.add<ForLowering, IfLowering, ParallelLowering, WhileLowering, patterns.add<ForLowering, IfLowering, ParallelLowering, WhileLowering,
ExecuteRegionLowering>(patterns.getContext()); ExecuteRegionLowering>(patterns.getContext());
patterns.add<DoWhileLowering>(patterns.getContext(), /*benefit=*/2); patterns.add<DoWhileLowering>(patterns.getContext(), /*benefit=*/2);
} }
void SCFToStandardPass::runOnOperation() { void SCFToControlFlowPass::runOnOperation() {
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateLoopToStdConversionPatterns(patterns); populateSCFToControlFlowConversionPatterns(patterns);
// Configure conversion to lower out scf.for, scf.if, scf.parallel and
// scf.while. Anything else is fine. // Configure conversion to lower out SCF operations.
ConversionTarget target(getContext()); ConversionTarget target(getContext());
target.addIllegalOp<scf::ForOp, scf::IfOp, scf::ParallelOp, scf::WhileOp, target.addIllegalOp<scf::ForOp, scf::IfOp, scf::ParallelOp, scf::WhileOp,
scf::ExecuteRegionOp>(); scf::ExecuteRegionOp>();
target.markUnknownOpDynamicallyLegal([](Operation *) { return true; }); target.markUnknownOpDynamicallyLegal([](Operation *) { return true; });
if (failed( if (failed(
applyPartialConversion(getOperation(), target, std::move(patterns)))) applyPartialConversion(getOperation(), target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
std::unique_ptr<Pass> mlir::createLowerToCFGPass() { std::unique_ptr<Pass> mlir::createConvertSCFToCFPass() {
return std::make_unique<SCFToStandardPass>(); return std::make_unique<SCFToControlFlowPass>();
} }

mlir/lib/Conversion/SCFToStandard/CMakeLists.txt

  • This file was moved to mlir/lib/Conversion/SCFToControlFlow/CMakeLists.txt.

mlir/lib/Conversion/SCFToStandard/SCFToStandard.cpp

  • This file was moved to mlir/lib/Conversion/SCFToControlFlow/SCFToControlFlow.cpp.

mlir/lib/Conversion/ShapeToStandard/ConvertShapeConstraints.cpp

//===- ConvertShapeConstraints.cpp - Conversion of shape constraints ------===// //===- ConvertShapeConstraints.cpp - Conversion of shape constraints ------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h" #include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h"
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Dialect/Shape/IR/Shape.h" #include "mlir/Dialect/Shape/IR/Shape.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Pass/PassRegistry.h" #include "mlir/Pass/PassRegistry.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
#include "ShapeToStandard.cpp.inc" #include "ShapeToStandard.cpp.inc"
} // namespace } // namespace
namespace { namespace {
class ConvertCstrRequireOp : public OpRewritePattern<shape::CstrRequireOp> { class ConvertCstrRequireOp : public OpRewritePattern<shape::CstrRequireOp> {
public: public:
using OpRewritePattern::OpRewritePattern; using OpRewritePattern::OpRewritePattern;
LogicalResult matchAndRewrite(shape::CstrRequireOp op, LogicalResult matchAndRewrite(shape::CstrRequireOp op,
PatternRewriter &rewriter) const override { PatternRewriter &rewriter) const override {
rewriter.create<AssertOp>(op.getLoc(), op.getPred(), op.getMsgAttr()); rewriter.create<cf::AssertOp>(op.getLoc(), op.getPred(), op.getMsgAttr());
rewriter.replaceOpWithNewOp<shape::ConstWitnessOp>(op, true); rewriter.replaceOpWithNewOp<shape::ConstWitnessOp>(op, true);
return success(); return success();
} }
}; };
} // namespace } // namespace
void mlir::populateConvertShapeConstraintsConversionPatterns( void mlir::populateConvertShapeConstraintsConversionPatterns(
RewritePatternSet &patterns) { RewritePatternSet &patterns) {
Show All 29 Lines

mlir/lib/Conversion/StandardToLLVM/CMakeLists.txt

add_mlir_conversion_library(MLIRStandardToLLVM add_mlir_conversion_library(MLIRStandardToLLVM
StandardToLLVM.cpp StandardToLLVM.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/StandardToLLVM ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/StandardToLLVM
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
intrinsics_gen intrinsics_gen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAnalysis MLIRAnalysis
MLIRArithmeticToLLVM MLIRArithmeticToLLVM
MLIRControlFlowToLLVM
MLIRDataLayoutInterfaces MLIRDataLayoutInterfaces
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMIR MLIRLLVMIR
MLIRMath MLIRMath
MLIRStandard MLIRStandard
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

//===- StandardToLLVM.cpp - Standard to LLVM dialect conversion -----------===// //===- StandardToLLVM.cpp - Standard to LLVM dialect conversion -----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to convert MLIR standard and builtin dialects // This file implements a pass to convert MLIR standard and builtin dialects
// into the LLVM IR dialect. // into the LLVM IR dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Analysis/DataLayoutAnalysis.h" #include "mlir/Analysis/DataLayoutAnalysis.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/LLVMCommon/VectorPattern.h" #include "mlir/Conversion/LLVMCommon/VectorPattern.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Dialect/LLVMIR/FunctionCallUtils.h" #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
▲ Show 20 Lines • Show All 357 Lines • ▼ Show 20 Lines for (auto it : llvm::zip(blockArgs, oldArgTypes)) {
rewriter.replaceOp(placeholder, {desc}); rewriter.replaceOp(placeholder, {desc});
} }
rewriter.eraseOp(funcOp); rewriter.eraseOp(funcOp);
return success(); return success();
} }
}; };
/// Lower `std.assert`. The default lowering calls the `abort` function if the
/// assertion is violated and has no effect otherwise. The failure message is
/// ignored by the default lowering but should be propagated by any custom
/// lowering.
struct AssertOpLowering : public ConvertOpToLLVMPattern<AssertOp> {
using ConvertOpToLLVMPattern<AssertOp>::ConvertOpToLLVMPattern;
LogicalResult
matchAndRewrite(AssertOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
auto loc = op.getLoc();
// Insert the `abort` declaration if necessary.
auto module = op->getParentOfType<ModuleOp>();
auto abortFunc = module.lookupSymbol<LLVM::LLVMFuncOp>("abort");
if (!abortFunc) {
OpBuilder::InsertionGuard guard(rewriter);
rewriter.setInsertionPointToStart(module.getBody());
auto abortFuncTy = LLVM::LLVMFunctionType::get(getVoidType(), {});
abortFunc = rewriter.create<LLVM::LLVMFuncOp>(rewriter.getUnknownLoc(),
"abort", abortFuncTy);
}
// Split block at `assert` operation.
Block *opBlock = rewriter.getInsertionBlock();
auto opPosition = rewriter.getInsertionPoint();
Block *continuationBlock = rewriter.splitBlock(opBlock, opPosition);
// Generate IR to call `abort`.
Block *failureBlock = rewriter.createBlock(opBlock->getParent());
rewriter.create<LLVM::CallOp>(loc, abortFunc, llvm::None);
rewriter.create<LLVM::UnreachableOp>(loc);
// Generate assertion test.
rewriter.setInsertionPointToEnd(opBlock);
rewriter.replaceOpWithNewOp<LLVM::CondBrOp>(
op, adaptor.getArg(), continuationBlock, failureBlock);
return success();
}
};
struct ConstantOpLowering : public ConvertOpToLLVMPattern<ConstantOp> { struct ConstantOpLowering : public ConvertOpToLLVMPattern<ConstantOp> {
using ConvertOpToLLVMPattern<ConstantOp>::ConvertOpToLLVMPattern; using ConvertOpToLLVMPattern<ConstantOp>::ConvertOpToLLVMPattern;
LogicalResult LogicalResult
matchAndRewrite(ConstantOp op, OpAdaptor adaptor, matchAndRewrite(ConstantOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override { ConversionPatternRewriter &rewriter) const override {
auto type = typeConverter->convertType(op.getResult().getType()); auto type = typeConverter->convertType(op.getResult().getType());
if (!type || !LLVM::isCompatibleType(type)) if (!type || !LLVM::isCompatibleType(type))
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Lines if (succeeded(typeConverter->convertTypes(adaptor.inputs().getTypes(),
convertedTypes == op.outputs().getType()) { convertedTypes == op.outputs().getType()) {
rewriter.replaceOp(op, adaptor.inputs()); rewriter.replaceOp(op, adaptor.inputs());
return success(); return success();
} }
return failure(); return failure();
} }
}; };
// Base class for LLVM IR lowering terminator operations with successors.
template <typename SourceOp, typename TargetOp>
struct OneToOneLLVMTerminatorLowering
: public ConvertOpToLLVMPattern<SourceOp> {
using ConvertOpToLLVMPattern<SourceOp>::ConvertOpToLLVMPattern;
using Super = OneToOneLLVMTerminatorLowering<SourceOp, TargetOp>;
LogicalResult
matchAndRewrite(SourceOp op, typename SourceOp::Adaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
rewriter.replaceOpWithNewOp<TargetOp>(op, adaptor.getOperands(),
op->getSuccessors(), op->getAttrs());
return success();
}
};
// Special lowering pattern for `ReturnOps`. Unlike all other operations, // Special lowering pattern for `ReturnOps`. Unlike all other operations,
// `ReturnOp` interacts with the function signature and must have as many // `ReturnOp` interacts with the function signature and must have as many
// operands as the function has return values. Because in LLVM IR, functions // operands as the function has return values. Because in LLVM IR, functions
// can only return 0 or 1 value, we pack multiple values into a structure type. // can only return 0 or 1 value, we pack multiple values into a structure type.
// Emit `UndefOp` followed by `InsertValueOp`s to create such structure if // Emit `UndefOp` followed by `InsertValueOp`s to create such structure if
// necessary before returning it // necessary before returning it
struct ReturnOpLowering : public ConvertOpToLLVMPattern<ReturnOp> { struct ReturnOpLowering : public ConvertOpToLLVMPattern<ReturnOp> {
using ConvertOpToLLVMPattern<ReturnOp>::ConvertOpToLLVMPattern; using ConvertOpToLLVMPattern<ReturnOp>::ConvertOpToLLVMPattern;
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines for (unsigned i = 0; i < numArguments; ++i) {
loc, packedType, packed, updatedOperands[i], loc, packedType, packed, updatedOperands[i],
rewriter.getI64ArrayAttr(i)); rewriter.getI64ArrayAttr(i));
} }
rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, TypeRange(), packed, rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, TypeRange(), packed,
op->getAttrs()); op->getAttrs());
return success(); return success();
} }
}; };
// FIXME: this should be tablegen'ed as well.
struct BranchOpLowering
: public OneToOneLLVMTerminatorLowering<BranchOp, LLVM::BrOp> {
using Super::Super;
};
struct CondBranchOpLowering
: public OneToOneLLVMTerminatorLowering<CondBranchOp, LLVM::CondBrOp> {
using Super::Super;
};
struct SwitchOpLowering
: public OneToOneLLVMTerminatorLowering<SwitchOp, LLVM::SwitchOp> {
using Super::Super;
};
} // namespace } // namespace
void mlir::populateStdToLLVMFuncOpConversionPattern( void mlir::populateStdToLLVMFuncOpConversionPattern(
LLVMTypeConverter &converter, RewritePatternSet &patterns) { LLVMTypeConverter &converter, RewritePatternSet &patterns) {
if (converter.getOptions().useBarePtrCallConv) if (converter.getOptions().useBarePtrCallConv)
patterns.add<BarePtrFuncOpConversion>(converter); patterns.add<BarePtrFuncOpConversion>(converter);
else else
patterns.add<FuncOpConversion>(converter); patterns.add<FuncOpConversion>(converter);
} }
void mlir::populateStdToLLVMConversionPatterns(LLVMTypeConverter &converter, void mlir::populateStdToLLVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns) { RewritePatternSet &patterns) {
populateStdToLLVMFuncOpConversionPattern(converter, patterns); populateStdToLLVMFuncOpConversionPattern(converter, patterns);
// clang-format off // clang-format off
patterns.add< patterns.add<
AssertOpLowering,
BranchOpLowering,
CallIndirectOpLowering, CallIndirectOpLowering,
CallOpLowering, CallOpLowering,
CondBranchOpLowering,
ConstantOpLowering, ConstantOpLowering,
ReturnOpLowering, ReturnOpLowering>(converter);
SwitchOpLowering>(converter);
// clang-format on // clang-format on
} }
namespace { namespace {
/// A pass converting MLIR operations into the LLVM IR dialect. /// A pass converting MLIR operations into the LLVM IR dialect.
struct LLVMLoweringPass : public ConvertStandardToLLVMBase<LLVMLoweringPass> { struct LLVMLoweringPass : public ConvertStandardToLLVMBase<LLVMLoweringPass> {
LLVMLoweringPass() = default; LLVMLoweringPass() = default;
LLVMLoweringPass(bool useBarePtrCallConv, bool emitCWrappers, LLVMLoweringPass(bool useBarePtrCallConv, bool emitCWrappers,
Show All 34 Lines void runOnOperation() override {
options.dataLayout = llvm::DataLayout(this->dataLayout); options.dataLayout = llvm::DataLayout(this->dataLayout);
LLVMTypeConverter typeConverter(&getContext(), options, LLVMTypeConverter typeConverter(&getContext(), options,
&dataLayoutAnalysis); &dataLayoutAnalysis);
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateStdToLLVMConversionPatterns(typeConverter, patterns); populateStdToLLVMConversionPatterns(typeConverter, patterns);
arith::populateArithmeticToLLVMConversionPatterns(typeConverter, patterns); arith::populateArithmeticToLLVMConversionPatterns(typeConverter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
if (failed(applyPartialConversion(m, target, std::move(patterns)))) if (failed(applyPartialConversion(m, target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
m->setAttr(LLVM::LLVMDialect::getDataLayoutAttrName(), m->setAttr(LLVM::LLVMDialect::getDataLayoutAttrName(),
StringAttr::get(m.getContext(), this->dataLayout)); StringAttr::get(m.getContext(), this->dataLayout));
} }
Show All 20 Lines

mlir/lib/Conversion/StandardToSPIRV/CMakeLists.txt

  • This file was copied to mlir/lib/Conversion/ControlFlowToSPIRV/CMakeLists.txt.
add_mlir_conversion_library(MLIRStandardToSPIRV add_mlir_conversion_library(MLIRStandardToSPIRV
StandardToSPIRV.cpp StandardToSPIRV.cpp
StandardToSPIRVPass.cpp StandardToSPIRVPass.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
${MLIR_MAIN_INCLUDE_DIR}/mlir/IR ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticToSPIRV MLIRArithmeticToSPIRV
MLIRControlFlowToSPIRV
MLIRIR MLIRIR
MLIRMathToSPIRV MLIRMathToSPIRV
MLIRMemRef MLIRMemRef
MLIRPass MLIRPass
MLIRSPIRV MLIRSPIRV
MLIRSPIRVConversion MLIRSPIRVConversion
MLIRSupport MLIRSupport
MLIRTransformUtils MLIRTransformUtils
MLIRStandard MLIRStandard
MLIRTensor MLIRTensor
) )

mlir/lib/Conversion/StandardToSPIRV/StandardToSPIRV.cpp

Show All 40 Lines
public: public:
using OpConversionPattern<ReturnOp>::OpConversionPattern; using OpConversionPattern<ReturnOp>::OpConversionPattern;
LogicalResult LogicalResult
matchAndRewrite(ReturnOp returnOp, OpAdaptor adaptor, matchAndRewrite(ReturnOp returnOp, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override; ConversionPatternRewriter &rewriter) const override;
}; };
/// Converts std.br to spv.Branch.
struct BranchOpPattern final : public OpConversionPattern<BranchOp> {
using OpConversionPattern<BranchOp>::OpConversionPattern;
LogicalResult
matchAndRewrite(BranchOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override;
};
/// Converts std.cond_br to spv.BranchConditional.
struct CondBranchOpPattern final : public OpConversionPattern<CondBranchOp> {
using OpConversionPattern<CondBranchOp>::OpConversionPattern;
LogicalResult
matchAndRewrite(CondBranchOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override;
};
/// Converts tensor.extract into loading using access chains from SPIR-V local /// Converts tensor.extract into loading using access chains from SPIR-V local
/// variables. /// variables.
class TensorExtractPattern final class TensorExtractPattern final
: public OpConversionPattern<tensor::ExtractOp> { : public OpConversionPattern<tensor::ExtractOp> {
public: public:
TensorExtractPattern(TypeConverter &typeConverter, MLIRContext *context, TensorExtractPattern(TypeConverter &typeConverter, MLIRContext *context,
int64_t threshold, PatternBenefit benefit = 1) int64_t threshold, PatternBenefit benefit = 1)
: OpConversionPattern(typeConverter, context, benefit), : OpConversionPattern(typeConverter, context, benefit),
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines rewriter.replaceOpWithNewOp<spirv::ReturnValueOp>(returnOp,
adaptor.getOperands()[0]); adaptor.getOperands()[0]);
} else { } else {
rewriter.replaceOpWithNewOp<spirv::ReturnOp>(returnOp); rewriter.replaceOpWithNewOp<spirv::ReturnOp>(returnOp);
} }
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// BranchOpPattern
//===----------------------------------------------------------------------===//
LogicalResult
BranchOpPattern::matchAndRewrite(BranchOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const {
rewriter.replaceOpWithNewOp<spirv::BranchOp>(op, op.getDest(),
adaptor.getDestOperands());
return success();
}
//===----------------------------------------------------------------------===//
// CondBranchOpPattern
//===----------------------------------------------------------------------===//
LogicalResult CondBranchOpPattern::matchAndRewrite(
CondBranchOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const {
rewriter.replaceOpWithNewOp<spirv::BranchConditionalOp>(
op, op.getCondition(), op.getTrueDest(), adaptor.getTrueDestOperands(),
op.getFalseDest(), adaptor.getFalseDestOperands());
return success();
}
//===----------------------------------------------------------------------===//
// Pattern population // Pattern population
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
namespace mlir { namespace mlir {
void populateStandardToSPIRVPatterns(SPIRVTypeConverter &typeConverter, void populateStandardToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
RewritePatternSet &patterns) { RewritePatternSet &patterns) {
MLIRContext *context = patterns.getContext(); MLIRContext *context = patterns.getContext();
patterns.add< patterns.add<
// Unary and binary patterns // Unary and binary patterns
spirv::ElementwiseOpPattern<arith::MaxFOp, spirv::GLSLFMaxOp>, spirv::ElementwiseOpPattern<arith::MaxFOp, spirv::GLSLFMaxOp>,
spirv::ElementwiseOpPattern<arith::MaxSIOp, spirv::GLSLSMaxOp>, spirv::ElementwiseOpPattern<arith::MaxSIOp, spirv::GLSLSMaxOp>,
spirv::ElementwiseOpPattern<arith::MaxUIOp, spirv::GLSLUMaxOp>, spirv::ElementwiseOpPattern<arith::MaxUIOp, spirv::GLSLUMaxOp>,
spirv::ElementwiseOpPattern<arith::MinFOp, spirv::GLSLFMinOp>, spirv::ElementwiseOpPattern<arith::MinFOp, spirv::GLSLFMinOp>,
spirv::ElementwiseOpPattern<arith::MinSIOp, spirv::GLSLSMinOp>, spirv::ElementwiseOpPattern<arith::MinSIOp, spirv::GLSLSMinOp>,
spirv::ElementwiseOpPattern<arith::MinUIOp, spirv::GLSLUMinOp>, spirv::ElementwiseOpPattern<arith::MinUIOp, spirv::GLSLUMinOp>,
ReturnOpPattern, BranchOpPattern, CondBranchOpPattern>(typeConverter, ReturnOpPattern>(typeConverter, context);
context);
} }
void populateTensorToSPIRVPatterns(SPIRVTypeConverter &typeConverter, void populateTensorToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
int64_t byteCountThreshold, int64_t byteCountThreshold,
RewritePatternSet &patterns) { RewritePatternSet &patterns) {
patterns.add<TensorExtractPattern>(typeConverter, patterns.getContext(), patterns.add<TensorExtractPattern>(typeConverter, patterns.getContext(),
byteCountThreshold); byteCountThreshold);
} }
} // namespace mlir } // namespace mlir

mlir/lib/Conversion/StandardToSPIRV/StandardToSPIRVPass.cpp

//===- StandardToSPIRVPass.cpp - Standard to SPIR-V Passes ----------------===// //===- StandardToSPIRVPass.cpp - Standard to SPIR-V Passes ----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to convert standard dialect to SPIR-V dialect. // This file implements a pass to convert standard dialect to SPIR-V dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/StandardToSPIRV/StandardToSPIRVPass.h" #include "mlir/Conversion/StandardToSPIRV/StandardToSPIRVPass.h"
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h" #include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h"
#include "mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRV.h"
#include "mlir/Conversion/MathToSPIRV/MathToSPIRV.h" #include "mlir/Conversion/MathToSPIRV/MathToSPIRV.h"
#include "mlir/Conversion/StandardToSPIRV/StandardToSPIRV.h" #include "mlir/Conversion/StandardToSPIRV/StandardToSPIRV.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
Show All 11 Linesvoid ConvertStandardToSPIRVPass::runOnOperation() {
auto targetAttr = spirv::lookupTargetEnvOrDefault(module); auto targetAttr = spirv::lookupTargetEnvOrDefault(module);
std::unique_ptr<ConversionTarget> target = std::unique_ptr<ConversionTarget> target =
SPIRVConversionTarget::get(targetAttr); SPIRVConversionTarget::get(targetAttr);
SPIRVTypeConverter::Options options; SPIRVTypeConverter::Options options;
options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes; options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes;
SPIRVTypeConverter typeConverter(targetAttr, options); SPIRVTypeConverter typeConverter(targetAttr, options);
// TODO ArithmeticToSPIRV cannot be applied separately to StandardToSPIRV // TODO ArithmeticToSPIRV/ControlFlowToSPIRV cannot be applied separately to
// StandardToSPIRV
RewritePatternSet patterns(context); RewritePatternSet patterns(context);
arith::populateArithmeticToSPIRVPatterns(typeConverter, patterns); arith::populateArithmeticToSPIRVPatterns(typeConverter, patterns);
cf::populateControlFlowToSPIRVPatterns(typeConverter, patterns);
populateMathToSPIRVPatterns(typeConverter, patterns); populateMathToSPIRVPatterns(typeConverter, patterns);
populateStandardToSPIRVPatterns(typeConverter, patterns); populateStandardToSPIRVPatterns(typeConverter, patterns);
populateTensorToSPIRVPatterns(typeConverter, /*byteCountThreshold=*/64, populateTensorToSPIRVPatterns(typeConverter, /*byteCountThreshold=*/64,
patterns); patterns);
populateBuiltinFuncToSPIRVPatterns(typeConverter, patterns); populateBuiltinFuncToSPIRVPatterns(typeConverter, patterns);
if (failed(applyPartialConversion(module, *target, std::move(patterns)))) if (failed(applyPartialConversion(module, *target, std::move(patterns))))
return signalPassFailure(); return signalPassFailure();
} }
std::unique_ptr<OperationPass<ModuleOp>> std::unique_ptr<OperationPass<ModuleOp>>
mlir::createConvertStandardToSPIRVPass() { mlir::createConvertStandardToSPIRVPass() {
return std::make_unique<ConvertStandardToSPIRVPass>(); return std::make_unique<ConvertStandardToSPIRVPass>();
} }

mlir/lib/Dialect/Async/Transforms/AsyncRuntimeRefCounting.cpp

Show All 9 Lines
// operations and types. // operations and types.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PassDetail.h" #include "PassDetail.h"
#include "mlir/Analysis/Liveness.h" #include "mlir/Analysis/Liveness.h"
#include "mlir/Dialect/Async/IR/Async.h" #include "mlir/Dialect/Async/IR/Async.h"
#include "mlir/Dialect/Async/Passes.h" #include "mlir/Dialect/Async/Passes.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "llvm/ADT/SmallSet.h" #include "llvm/ADT/SmallSet.h"
using namespace mlir; using namespace mlir;
using namespace mlir::async; using namespace mlir::async;
▲ Show 20 Lines • Show All 138 Lines • ▼ Show 20 Linesprivate:
/// (#3) Adds the `drop_ref` operation to account for successor blocks with /// (#3) Adds the `drop_ref` operation to account for successor blocks with
/// divergent `liveIn` property: `value` is not in the `liveIn` set of all /// divergent `liveIn` property: `value` is not in the `liveIn` set of all
/// successor blocks. /// successor blocks.
/// ///
/// Example: /// Example:
/// ///
/// ^entry: /// ^entry:
/// %token = async.runtime.create : !async.token /// %token = async.runtime.create : !async.token
/// cond_br %cond, ^bb1, ^bb2 /// cf.cond_br %cond, ^bb1, ^bb2
/// ^bb1: /// ^bb1:
/// async.runtime.await %token /// async.runtime.await %token
/// async.runtime.drop_ref %token /// async.runtime.drop_ref %token
/// br ^bb2 /// cf.br ^bb2
/// ^bb2: /// ^bb2:
/// return /// return
/// ///
/// In this example ^bb2 does not have `value` in the `liveIn` set, so we have /// In this example ^bb2 does not have `value` in the `liveIn` set, so we have
/// to branch into a special "reference counting block" from the ^entry that /// to branch into a special "reference counting block" from the ^entry that
/// will have a `drop_ref` operation, and then branch into the ^bb2. /// will have a `drop_ref` operation, and then branch into the ^bb2.
/// ///
/// After transformation: /// After transformation:
/// ///
/// ^entry: /// ^entry:
/// %token = async.runtime.create : !async.token /// %token = async.runtime.create : !async.token
/// cond_br %cond, ^bb1, ^reference_counting /// cf.cond_br %cond, ^bb1, ^reference_counting
/// ^bb1: /// ^bb1:
/// async.runtime.await %token /// async.runtime.await %token
/// async.runtime.drop_ref %token /// async.runtime.drop_ref %token
/// br ^bb2 /// cf.br ^bb2
/// ^reference_counting: /// ^reference_counting:
/// async.runtime.drop_ref %token /// async.runtime.drop_ref %token
/// br ^bb2 /// cf.br ^bb2
/// ^bb2: /// ^bb2:
/// return /// return
/// ///
/// An exception to this rule are blocks with `async.coro.suspend` terminator, /// An exception to this rule are blocks with `async.coro.suspend` terminator,
/// because in Async to LLVM lowering it is guaranteed that the control flow /// because in Async to LLVM lowering it is guaranteed that the control flow
/// will jump into the resume block, and then follow into the cleanup and /// will jump into the resume block, and then follow into the cleanup and
/// suspend blocks. /// suspend blocks.
/// ///
/// Example: /// Example:
/// ///
/// ^entry(%value: !async.value<f32>): /// ^entry(%value: !async.value<f32>):
/// async.runtime.await_and_resume %value, %hdl : !async.value<f32> /// async.runtime.await_and_resume %value, %hdl : !async.value<f32>
/// async.coro.suspend %ret, ^suspend, ^resume, ^cleanup /// async.coro.suspend %ret, ^suspend, ^resume, ^cleanup
/// ^resume: /// ^resume:
/// %0 = async.runtime.load %value /// %0 = async.runtime.load %value
/// br ^cleanup /// cf.br ^cleanup
/// ^cleanup: /// ^cleanup:
/// ... /// ...
/// ^suspend: /// ^suspend:
/// ... /// ...
/// ///
/// Although cleanup and suspend blocks do not have the `value` in the /// Although cleanup and suspend blocks do not have the `value` in the
/// `liveIn` set, it is guaranteed that execution will eventually continue in /// `liveIn` set, it is guaranteed that execution will eventually continue in
/// the resume block (we never explicitly destroy coroutines). /// the resume block (we never explicitly destroy coroutines).
▲ Show 20 Lines • Show All 181 Lines • ▼ Show 20 Lines for (Block *successor : successors) {
Block *refCountingBlock = nullptr; Block *refCountingBlock = nullptr;
if (successor->getUniquePredecessor() == block) { if (successor->getUniquePredecessor() == block) {
refCountingBlock = successor; refCountingBlock = successor;
} else { } else {
refCountingBlock = &successor->getParent()->emplaceBlock(); refCountingBlock = &successor->getParent()->emplaceBlock();
refCountingBlock->moveBefore(successor); refCountingBlock->moveBefore(successor);
OpBuilder builder = OpBuilder::atBlockEnd(refCountingBlock); OpBuilder builder = OpBuilder::atBlockEnd(refCountingBlock);
builder.create<BranchOp>(value.getLoc(), successor); builder.create<cf::BranchOp>(value.getLoc(), successor);
} }
OpBuilder builder = OpBuilder::atBlockBegin(refCountingBlock); OpBuilder builder = OpBuilder::atBlockBegin(refCountingBlock);
builder.create<RuntimeDropRefOp>(value.getLoc(), value, builder.create<RuntimeDropRefOp>(value.getLoc(), value,
builder.getI64IntegerAttr(1)); builder.getI64IntegerAttr(1));
// No need to update the terminator operation. // No need to update the terminator operation.
if (successor == refCountingBlock) if (successor == refCountingBlock)
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp

//===- AsyncToAsyncRuntime.cpp - Lower from Async to Async Runtime --------===// //===- AsyncToAsyncRuntime.cpp - Lower from Async to Async Runtime --------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements lowering from high level async operations to async.coro // This file implements lowering from high level async operations to async.coro
// and async.runtime operations. // and async.runtime operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PassDetail.h" #include "PassDetail.h"
#include "mlir/Conversion/SCFToStandard/SCFToStandard.h" #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Async/IR/Async.h" #include "mlir/Dialect/Async/IR/Async.h"
#include "mlir/Dialect/Async/Passes.h" #include "mlir/Dialect/Async/Passes.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/RegionUtils.h" #include "mlir/Transforms/RegionUtils.h"
#include "llvm/ADT/SetVector.h" #include "llvm/ADT/SetVector.h"
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines
/// ///
/// func @some_fn(<function-arguments>) -> (!async.token, !async.value<T>) /// func @some_fn(<function-arguments>) -> (!async.token, !async.value<T>)
/// { /// {
/// ^entry(<function-arguments>): /// ^entry(<function-arguments>):
/// %token = <async token> : !async.token // create async runtime token /// %token = <async token> : !async.token // create async runtime token
/// %value = <async value> : !async.value<T> // create async value /// %value = <async value> : !async.value<T> // create async value
/// %id = async.coro.id // create a coroutine id /// %id = async.coro.id // create a coroutine id
/// %hdl = async.coro.begin %id // create a coroutine handle /// %hdl = async.coro.begin %id // create a coroutine handle
/// br ^preexisting_entry_block /// cf.br ^preexisting_entry_block
/// ///
/// /* preexisting blocks modified to branch to the cleanup block */ /// /* preexisting blocks modified to branch to the cleanup block */
/// ///
/// ^set_error: // this block created lazily only if needed (see code below) /// ^set_error: // this block created lazily only if needed (see code below)
/// async.runtime.set_error %token : !async.token /// async.runtime.set_error %token : !async.token
/// async.runtime.set_error %value : !async.value<T> /// async.runtime.set_error %value : !async.value<T>
/// br ^cleanup /// cf.br ^cleanup
/// ///
/// ^cleanup: /// ^cleanup:
/// async.coro.free %hdl // delete the coroutine state /// async.coro.free %hdl // delete the coroutine state
/// br ^suspend /// cf.br ^suspend
/// ///
/// ^suspend: /// ^suspend:
/// async.coro.end %hdl // marks the end of a coroutine /// async.coro.end %hdl // marks the end of a coroutine
/// return %token, %value : !async.token, !async.value<T> /// return %token, %value : !async.token, !async.value<T>
/// } /// }
/// ///
static CoroMachinery setupCoroMachinery(FuncOp func) { static CoroMachinery setupCoroMachinery(FuncOp func) {
assert(!func.getBlocks().empty() && "Function must have an entry block"); assert(!func.getBlocks().empty() && "Function must have an entry block");
Show All 14 Lines for (auto resType : func.getCallableResults().drop_front())
retValues.emplace_back(builder.create<RuntimeCreateOp>(resType).result()); retValues.emplace_back(builder.create<RuntimeCreateOp>(resType).result());
// ------------------------------------------------------------------------ // // ------------------------------------------------------------------------ //
// Initialize coroutine: get coroutine id and coroutine handle. // Initialize coroutine: get coroutine id and coroutine handle.
// ------------------------------------------------------------------------ // // ------------------------------------------------------------------------ //
auto coroIdOp = builder.create<CoroIdOp>(CoroIdType::get(ctx)); auto coroIdOp = builder.create<CoroIdOp>(CoroIdType::get(ctx));
auto coroHdlOp = auto coroHdlOp =
builder.create<CoroBeginOp>(CoroHandleType::get(ctx), coroIdOp.id()); builder.create<CoroBeginOp>(CoroHandleType::get(ctx), coroIdOp.id());
builder.create<BranchOp>(originalEntryBlock); builder.create<cf::BranchOp>(originalEntryBlock);
Block *cleanupBlock = func.addBlock(); Block *cleanupBlock = func.addBlock();
Block *suspendBlock = func.addBlock(); Block *suspendBlock = func.addBlock();
// ------------------------------------------------------------------------ // // ------------------------------------------------------------------------ //
// Coroutine cleanup block: deallocate coroutine frame, free the memory. // Coroutine cleanup block: deallocate coroutine frame, free the memory.
// ------------------------------------------------------------------------ // // ------------------------------------------------------------------------ //
builder.setInsertionPointToStart(cleanupBlock); builder.setInsertionPointToStart(cleanupBlock);
builder.create<CoroFreeOp>(coroIdOp.id(), coroHdlOp.handle()); builder.create<CoroFreeOp>(coroIdOp.id(), coroHdlOp.handle());
// Branch into the suspend block. // Branch into the suspend block.
builder.create<BranchOp>(suspendBlock); builder.create<cf::BranchOp>(suspendBlock);
// ------------------------------------------------------------------------ // // ------------------------------------------------------------------------ //
// Coroutine suspend block: mark the end of a coroutine and return allocated // Coroutine suspend block: mark the end of a coroutine and return allocated
// async token. // async token.
// ------------------------------------------------------------------------ // // ------------------------------------------------------------------------ //
builder.setInsertionPointToStart(suspendBlock); builder.setInsertionPointToStart(suspendBlock);
// Mark the end of a coroutine: async.coro.end // Mark the end of a coroutine: async.coro.end
Show All 10 Linesstatic CoroMachinery setupCoroMachinery(FuncOp func) {
for (Block &block : func.body().getBlocks()) { for (Block &block : func.body().getBlocks()) {
if (&block == entryBlock || &block == cleanupBlock || if (&block == entryBlock || &block == cleanupBlock ||
&block == suspendBlock) &block == suspendBlock)
continue; continue;
Operation *terminator = block.getTerminator(); Operation *terminator = block.getTerminator();
if (auto yield = dyn_cast<YieldOp>(terminator)) { if (auto yield = dyn_cast<YieldOp>(terminator)) {
builder.setInsertionPointToEnd(&block); builder.setInsertionPointToEnd(&block);
builder.create<BranchOp>(cleanupBlock); builder.create<cf::BranchOp>(cleanupBlock);
} }
} }
// The switch-resumed API based coroutine should be marked with // The switch-resumed API based coroutine should be marked with
// "coroutine.presplit" attribute with value "0" to mark the function as a // "coroutine.presplit" attribute with value "0" to mark the function as a
// coroutine. // coroutine.
func->setAttr("passthrough", builder.getArrayAttr(builder.getArrayAttr( func->setAttr("passthrough", builder.getArrayAttr(builder.getArrayAttr(
{builder.getStringAttr("coroutine.presplit"), {builder.getStringAttr("coroutine.presplit"),
Show All 24 Lines auto builder =
ImplicitLocOpBuilder::atBlockBegin(coro.func->getLoc(), coro.setError); ImplicitLocOpBuilder::atBlockBegin(coro.func->getLoc(), coro.setError);
// Coroutine set_error block: set error on token and all returned values. // Coroutine set_error block: set error on token and all returned values.
builder.create<RuntimeSetErrorOp>(coro.asyncToken); builder.create<RuntimeSetErrorOp>(coro.asyncToken);
for (Value retValue : coro.returnValues) for (Value retValue : coro.returnValues)
builder.create<RuntimeSetErrorOp>(retValue); builder.create<RuntimeSetErrorOp>(retValue);
// Branch into the cleanup block. // Branch into the cleanup block.
builder.create<BranchOp>(coro.cleanup); builder.create<cf::BranchOp>(coro.cleanup);
return coro.setError; return coro.setError;
} }
/// Outline the body region attached to the `async.execute` op into a standalone /// Outline the body region attached to the `async.execute` op into a standalone
/// function. /// function.
/// ///
/// Note that this is not reversible transformation. /// Note that this is not reversible transformation.
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 LinesoutlineExecuteOp(SymbolTable &symbolTable, ExecuteOp execute) {
// Adding entry/cleanup/suspend blocks. // Adding entry/cleanup/suspend blocks.
CoroMachinery coro = setupCoroMachinery(func); CoroMachinery coro = setupCoroMachinery(func);
// Suspend async function at the end of an entry block, and resume it using // Suspend async function at the end of an entry block, and resume it using
// Async resume operation (execution will be resumed in a thread managed by // Async resume operation (execution will be resumed in a thread managed by
// the async runtime). // the async runtime).
{ {
BranchOp branch = cast<BranchOp>(coro.entry->getTerminator()); cf::BranchOp branch = cast<cf::BranchOp>(coro.entry->getTerminator());
builder.setInsertionPointToEnd(coro.entry); builder.setInsertionPointToEnd(coro.entry);
// Save the coroutine state: async.coro.save // Save the coroutine state: async.coro.save
auto coroSaveOp = auto coroSaveOp =
builder.create<CoroSaveOp>(CoroStateType::get(ctx), coro.coroHandle); builder.create<CoroSaveOp>(CoroStateType::get(ctx), coro.coroHandle);
// Pass coroutine to the runtime to be resumed on a runtime managed // Pass coroutine to the runtime to be resumed on a runtime managed
// thread. // thread.
▲ Show 20 Lines • Show All 97 Lines • ▼ Show 20 Lines if (!isInCoroutine) {
builder.create<RuntimeAwaitOp>(loc, operand); builder.create<RuntimeAwaitOp>(loc, operand);
// Assert that the awaited operands is not in the error state. // Assert that the awaited operands is not in the error state.
Value isError = builder.create<RuntimeIsErrorOp>(i1, operand); Value isError = builder.create<RuntimeIsErrorOp>(i1, operand);
Value notError = builder.create<arith::XOrIOp>( Value notError = builder.create<arith::XOrIOp>(
isError, builder.create<arith::ConstantOp>( isError, builder.create<arith::ConstantOp>(
loc, i1, builder.getIntegerAttr(i1, 1))); loc, i1, builder.getIntegerAttr(i1, 1)));
builder.create<AssertOp>(notError, builder.create<cf::AssertOp>(notError,
"Awaited async operand is in error state"); "Awaited async operand is in error state");
} }
// Inside the coroutine we convert await operation into coroutine suspension // Inside the coroutine we convert await operation into coroutine suspension
// point, and resume execution asynchronously. // point, and resume execution asynchronously.
if (isInCoroutine) { if (isInCoroutine) {
CoroMachinery &coro = outlined->getSecond(); CoroMachinery &coro = outlined->getSecond();
Block *suspended = op->getBlock(); Block *suspended = op->getBlock();
Show All 15 Lines if (isInCoroutine) {
coro.cleanup); coro.cleanup);
// Split the resume block into error checking and continuation. // Split the resume block into error checking and continuation.
Block *continuation = rewriter.splitBlock(resume, Block::iterator(op)); Block *continuation = rewriter.splitBlock(resume, Block::iterator(op));
// Check if the awaited value is in the error state. // Check if the awaited value is in the error state.
builder.setInsertionPointToStart(resume); builder.setInsertionPointToStart(resume);
auto isError = builder.create<RuntimeIsErrorOp>(loc, i1, operand); auto isError = builder.create<RuntimeIsErrorOp>(loc, i1, operand);
builder.create<CondBranchOp>(isError, builder.create<cf::CondBranchOp>(isError,
/*trueDest=*/setupSetErrorBlock(coro), /*trueDest=*/setupSetErrorBlock(coro),
/*trueArgs=*/ArrayRef<Value>(), /*trueArgs=*/ArrayRef<Value>(),
/*falseDest=*/continuation, /*falseDest=*/continuation,
/*falseArgs=*/ArrayRef<Value>()); /*falseArgs=*/ArrayRef<Value>());
// Make sure that replacement value will be constructed in the // Make sure that replacement value will be constructed in the
// continuation block. // continuation block.
rewriter.setInsertionPointToStart(continuation); rewriter.setInsertionPointToStart(continuation);
} }
// Erase or replace the await operation with the new value. // Erase or replace the await operation with the new value.
if (Value replaceWith = getReplacementValue(op, operand, rewriter)) if (Value replaceWith = getReplacementValue(op, operand, rewriter))
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines matchAndRewrite(async::YieldOp op, OpAdaptor adaptor,
return success(); return success();
} }
private: private:
const llvm::DenseMap<FuncOp, CoroMachinery> &outlinedFunctions; const llvm::DenseMap<FuncOp, CoroMachinery> &outlinedFunctions;
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Convert std.assert operation to cond_br into `set_error` block. // Convert std.assert operation to cf.cond_br into `set_error` block.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
class AssertOpLowering : public OpConversionPattern<AssertOp> { class AssertOpLowering : public OpConversionPattern<cf::AssertOp> {
public: public:
AssertOpLowering(MLIRContext *ctx, AssertOpLowering(MLIRContext *ctx,
llvm::DenseMap<FuncOp, CoroMachinery> &outlinedFunctions) llvm::DenseMap<FuncOp, CoroMachinery> &outlinedFunctions)
: OpConversionPattern<AssertOp>(ctx), : OpConversionPattern<cf::AssertOp>(ctx),
outlinedFunctions(outlinedFunctions) {} outlinedFunctions(outlinedFunctions) {}
LogicalResult LogicalResult
matchAndRewrite(AssertOp op, OpAdaptor adaptor, matchAndRewrite(cf::AssertOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override { ConversionPatternRewriter &rewriter) const override {
// Check if assert operation is inside the async coroutine function. // Check if assert operation is inside the async coroutine function.
auto func = op->template getParentOfType<FuncOp>(); auto func = op->template getParentOfType<FuncOp>();
auto outlined = outlinedFunctions.find(func); auto outlined = outlinedFunctions.find(func);
if (outlined == outlinedFunctions.end()) if (outlined == outlinedFunctions.end())
return rewriter.notifyMatchFailure( return rewriter.notifyMatchFailure(
op, "operation is not inside the async coroutine function"); op, "operation is not inside the async coroutine function");
Location loc = op->getLoc(); Location loc = op->getLoc();
CoroMachinery &coro = outlined->getSecond(); CoroMachinery &coro = outlined->getSecond();
Block *cont = rewriter.splitBlock(op->getBlock(), Block::iterator(op)); Block *cont = rewriter.splitBlock(op->getBlock(), Block::iterator(op));
rewriter.setInsertionPointToEnd(cont->getPrevNode()); rewriter.setInsertionPointToEnd(cont->getPrevNode());
rewriter.create<CondBranchOp>(loc, adaptor.getArg(), rewriter.create<cf::CondBranchOp>(loc, adaptor.getArg(),
/*trueDest=*/cont, /*trueDest=*/cont,
/*trueArgs=*/ArrayRef<Value>(), /*trueArgs=*/ArrayRef<Value>(),
/*falseDest=*/setupSetErrorBlock(coro), /*falseDest=*/setupSetErrorBlock(coro),
/*falseArgs=*/ArrayRef<Value>()); /*falseArgs=*/ArrayRef<Value>());
rewriter.eraseOp(op); rewriter.eraseOp(op);
return success(); return success();
} }
private: private:
llvm::DenseMap<FuncOp, CoroMachinery> &outlinedFunctions; llvm::DenseMap<FuncOp, CoroMachinery> &outlinedFunctions;
}; };
▲ Show 20 Lines • Show All 159 Lines • ▼ Show 20 Linesvoid AsyncToAsyncRuntimePass::runOnOperation() {
// Lower async operations to async.runtime operations. // Lower async operations to async.runtime operations.
MLIRContext *ctx = module->getContext(); MLIRContext *ctx = module->getContext();
RewritePatternSet asyncPatterns(ctx); RewritePatternSet asyncPatterns(ctx);
// Conversion to async runtime augments original CFG with the coroutine CFG, // Conversion to async runtime augments original CFG with the coroutine CFG,
// and we have to make sure that structured control flow operations with async // and we have to make sure that structured control flow operations with async
// operations in nested regions will be converted to branch-based control flow // operations in nested regions will be converted to branch-based control flow
// before we add the coroutine basic blocks. // before we add the coroutine basic blocks.
populateLoopToStdConversionPatterns(asyncPatterns); populateSCFToControlFlowConversionPatterns(asyncPatterns);
// Async lowering does not use type converter because it must preserve all // Async lowering does not use type converter because it must preserve all
// types for async.runtime operations. // types for async.runtime operations.
asyncPatterns.add<CreateGroupOpLowering, AddToGroupOpLowering>(ctx); asyncPatterns.add<CreateGroupOpLowering, AddToGroupOpLowering>(ctx);
asyncPatterns.add<AwaitTokenOpLowering, AwaitValueOpLowering, asyncPatterns.add<AwaitTokenOpLowering, AwaitValueOpLowering,
AwaitAllOpLowering, YieldOpLowering>(ctx, AwaitAllOpLowering, YieldOpLowering>(ctx,
outlinedFunctions); outlinedFunctions);
Show All 10 Linesvoid AsyncToAsyncRuntimePass::runOnOperation() {
runtimeTarget.addDynamicallyLegalDialect<scf::SCFDialect>([&](Operation *op) { runtimeTarget.addDynamicallyLegalDialect<scf::SCFDialect>([&](Operation *op) {
auto walkResult = op->walk([&](Operation *nested) { auto walkResult = op->walk([&](Operation *nested) {
bool isAsync = isa<async::AsyncDialect>(nested->getDialect()); bool isAsync = isa<async::AsyncDialect>(nested->getDialect());
return isAsync && isInCoroutine(nested) ? WalkResult::interrupt() return isAsync && isInCoroutine(nested) ? WalkResult::interrupt()
: WalkResult::advance(); : WalkResult::advance();
}); });
return !walkResult.wasInterrupted(); return !walkResult.wasInterrupted();
}); });
runtimeTarget.addLegalOp<AssertOp, arith::XOrIOp, arith::ConstantOp, runtimeTarget.addLegalOp<cf::AssertOp, arith::XOrIOp, arith::ConstantOp,
ConstantOp, BranchOp, CondBranchOp>(); ConstantOp, cf::BranchOp, cf::CondBranchOp>();
// Assertions must be converted to runtime errors inside async functions. // Assertions must be converted to runtime errors inside async functions.
runtimeTarget.addDynamicallyLegalOp<AssertOp>([&](AssertOp op) -> bool { runtimeTarget.addDynamicallyLegalOp<cf::AssertOp>(
[&](cf::AssertOp op) -> bool {
auto func = op->getParentOfType<FuncOp>(); auto func = op->getParentOfType<FuncOp>();
return outlinedFunctions.find(func) == outlinedFunctions.end(); return outlinedFunctions.find(func) == outlinedFunctions.end();
}); });
if (eliminateBlockingAwaitOps) if (eliminateBlockingAwaitOps)
runtimeTarget.addDynamicallyLegalOp<RuntimeAwaitOp>( runtimeTarget.addDynamicallyLegalOp<RuntimeAwaitOp>(
[&](RuntimeAwaitOp op) -> bool { [&](RuntimeAwaitOp op) -> bool {
return isAllowedToBlock(op->getParentOfType<FuncOp>()); return isAllowedToBlock(op->getParentOfType<FuncOp>());
}); });
if (failed(applyPartialConversion(module, runtimeTarget, if (failed(applyPartialConversion(module, runtimeTarget,
Show All 9 Lines

mlir/lib/Dialect/Async/Transforms/CMakeLists.txt

Show All 11 Linesadd_mlir_dialect_library(MLIRAsyncTransforms
MLIRAsyncPassIncGen MLIRAsyncPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmetic MLIRArithmetic
MLIRAsync MLIRAsync
MLIRIR MLIRIR
MLIRPass MLIRPass
MLIRSCF MLIRSCF
MLIRSCFToStandard MLIRSCFToControlFlow
MLIRStandard MLIRStandard
MLIRTransforms MLIRTransforms
MLIRTransformUtils MLIRTransformUtils
) )

mlir/lib/Dialect/Bufferization/Transforms/BufferDeallocation.cpp

Show All 12 Lines
// order to put allocations and deallocations at safe positions, it is // order to put allocations and deallocations at safe positions, it is
// significantly important to put them into the correct blocks. However, the // significantly important to put them into the correct blocks. However, the
// liveness analysis does not pay attention to aliases, which can occur due to // liveness analysis does not pay attention to aliases, which can occur due to
// branches (and their associated block arguments) in general. For this purpose, // branches (and their associated block arguments) in general. For this purpose,
// BufferDeallocation firstly finds all possible aliases for a single value // BufferDeallocation firstly finds all possible aliases for a single value
// (using the BufferViewFlowAnalysis class). Consider the following example: // (using the BufferViewFlowAnalysis class). Consider the following example:
// //
// ^bb0(%arg0): // ^bb0(%arg0):
// cond_br %cond, ^bb1, ^bb2 // cf.cond_br %cond, ^bb1, ^bb2
// ^bb1: // ^bb1:
// br ^exit(%arg0) // cf.br ^exit(%arg0)
// ^bb2: // ^bb2:
// %new_value = ... // %new_value = ...
// br ^exit(%new_value) // cf.br ^exit(%new_value)
// ^exit(%arg1): // ^exit(%arg1):
// return %arg1; // return %arg1;
// //
// We should place the dealloc for %new_value in exit. However, we have to free // We should place the dealloc for %new_value in exit. However, we have to free
// the buffer in the same block, because it cannot be freed in the post // the buffer in the same block, because it cannot be freed in the post
// dominator. However, this requires a new clone buffer for %arg1 that will // dominator. However, this requires a new clone buffer for %arg1 that will
// contain the actual contents. Using the class BufferViewFlowAnalysis, we // contain the actual contents. Using the class BufferViewFlowAnalysis, we
// will find out that %new_value has a potential alias %arg1. In order to find // will find out that %new_value has a potential alias %arg1. In order to find
▲ Show 20 Lines • Show All 646 Lines • Show Last 20 Lines

mlir/lib/Dialect/CMakeLists.txt

add_subdirectory(Affine) add_subdirectory(Affine)
add_subdirectory(Arithmetic) add_subdirectory(Arithmetic)
add_subdirectory(ArmNeon) add_subdirectory(ArmNeon)
add_subdirectory(ArmSVE) add_subdirectory(ArmSVE)
add_subdirectory(Async) add_subdirectory(Async)
add_subdirectory(AMX) add_subdirectory(AMX)
add_subdirectory(Bufferization) add_subdirectory(Bufferization)
add_subdirectory(Complex) add_subdirectory(Complex)
add_subdirectory(ControlFlow)
add_subdirectory(DLTI) add_subdirectory(DLTI)
add_subdirectory(EmitC) add_subdirectory(EmitC)
add_subdirectory(GPU) add_subdirectory(GPU)
add_subdirectory(Linalg) add_subdirectory(Linalg)
add_subdirectory(LLVMIR) add_subdirectory(LLVMIR)
add_subdirectory(Math) add_subdirectory(Math)
add_subdirectory(MemRef) add_subdirectory(MemRef)
add_subdirectory(OpenACC) add_subdirectory(OpenACC)
Show All 28 Lines

mlir/lib/Dialect/ControlFlow/CMakeLists.txt

  • This file was added.
add_subdirectory(IR)

mlir/lib/Dialect/ControlFlow/IR/CMakeLists.txt

  • This file was added.
add_mlir_dialect_library(MLIRControlFlow
ControlFlowOps.cpp
ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/ControlFlow/IR
DEPENDS
MLIRControlFlowOpsIncGen
LINK_LIBS PUBLIC
MLIRArithmetic
MLIRControlFlowInterfaces
MLIRIR
MLIRSideEffectInterfaces
)

mlir/lib/Dialect/ControlFlow/IR/ControlFlowOps.cpp

  • This file was copied from mlir/lib/Dialect/StandardOps/IR/Ops.cpp.
//===- Ops.cpp - Standard MLIR Operations ---------------------------------===// //===- ControlFlowOps.cpp - ControlFlow Operations ------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
#include "mlir/Dialect/CommonFolders.h" #include "mlir/Dialect/CommonFolders.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/OpImplementation.h" #include "mlir/IR/OpImplementation.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/IR/TypeUtilities.h" #include "mlir/IR/TypeUtilities.h"
#include "mlir/IR/Value.h" #include "mlir/IR/Value.h"
#include "mlir/Support/MathExtras.h" #include "mlir/Support/MathExtras.h"
#include "mlir/Transforms/InliningUtils.h" #include "mlir/Transforms/InliningUtils.h"
#include "llvm/ADT/APFloat.h" #include "llvm/ADT/APFloat.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include <numeric> #include <numeric>
#include "mlir/Dialect/StandardOps/IR/OpsDialect.cpp.inc" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOpsDialect.cpp.inc"
// Pull in all enum type definitions and utility function declarations.
#include "mlir/Dialect/StandardOps/IR/OpsEnums.cpp.inc"
using namespace mlir; using namespace mlir;
using namespace mlir::cf;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// StandardOpsDialect Interfaces // ControlFlowDialect Interfaces
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
namespace { namespace {
/// This class defines the interface for handling inlining with standard /// This class defines the interface for handling inlining with control flow
/// operations. /// operations.
struct StdInlinerInterface : public DialectInlinerInterface { struct ControlFlowInlinerInterface : public DialectInlinerInterface {
using DialectInlinerInterface::DialectInlinerInterface; using DialectInlinerInterface::DialectInlinerInterface;
~ControlFlowInlinerInterface() override = default;
//===--------------------------------------------------------------------===// /// All control flow operations can be inlined.
// Analysis Hooks
//===--------------------------------------------------------------------===//
/// All call operations within standard ops can be inlined.
bool isLegalToInline(Operation *call, Operation *callable, bool isLegalToInline(Operation *call, Operation *callable,
bool wouldBeCloned) const final { bool wouldBeCloned) const final {
return true; return true;
} }
/// All operations within standard ops can be inlined.
bool isLegalToInline(Operation *, Region *, bool, bool isLegalToInline(Operation *, Region *, bool,
BlockAndValueMapping &) const final { BlockAndValueMapping &) const final {
return true; return true;
} }
//===--------------------------------------------------------------------===// /// ControlFlow terminator operations don't really need any special handing.
// Transformation Hooks void handleTerminator(Operation *op, Block *newDest) const final {}
//===--------------------------------------------------------------------===//
/// Handle the given inlined terminator by replacing it with a new operation
/// as necessary.
void handleTerminator(Operation *op, Block *newDest) const final {
// Only "std.return" needs to be handled here.
auto returnOp = dyn_cast<ReturnOp>(op);
if (!returnOp)
return;
// Replace the return with a branch to the dest.
OpBuilder builder(op);
builder.create<BranchOp>(op->getLoc(), newDest, returnOp.getOperands());
op->erase();
}
/// Handle the given inlined terminator by replacing it with a new operation
/// as necessary.
void handleTerminator(Operation *op,
ArrayRef<Value> valuesToRepl) const final {
// Only "std.return" needs to be handled here.
auto returnOp = cast<ReturnOp>(op);
// Replace the values directly with the return operands.
assert(returnOp.getNumOperands() == valuesToRepl.size());
for (const auto &it : llvm::enumerate(returnOp.getOperands()))
valuesToRepl[it.index()].replaceAllUsesWith(it.value());
}
}; };
} // namespace } // namespace
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// StandardOpsDialect // ControlFlowDialect
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void StandardOpsDialect::initialize() { void ControlFlowDialect::initialize() {
addOperations< addOperations<
#define GET_OP_LIST #define GET_OP_LIST
#include "mlir/Dialect/StandardOps/IR/Ops.cpp.inc" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.cpp.inc"
>(); >();
addInterfaces<StdInlinerInterface>(); addInterfaces<ControlFlowInlinerInterface>();
}
/// Materialize a single constant operation from a given attribute value with
/// the desired resultant type.
Operation *StandardOpsDialect::materializeConstant(OpBuilder &builder,
Attribute value, Type type,
Location loc) {
if (arith::ConstantOp::isBuildableWith(value, type))
return builder.create<arith::ConstantOp>(loc, type, value);
if (ConstantOp::isBuildableWith(value, type))
return builder.create<ConstantOp>(loc, type,
value.cast<FlatSymbolRefAttr>());
return nullptr;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AssertOp // AssertOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
LogicalResult AssertOp::canonicalize(AssertOp op, PatternRewriter &rewriter) { LogicalResult AssertOp::canonicalize(AssertOp op, PatternRewriter &rewriter) {
// Erase assertion if argument is constant true. // Erase assertion if argument is constant true.
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 LinesBranchOp::getMutableSuccessorOperands(unsigned index) {
return getDestOperandsMutable(); return getDestOperandsMutable();
} }
Block *BranchOp::getSuccessorForOperands(ArrayRef<Attribute>) { Block *BranchOp::getSuccessorForOperands(ArrayRef<Attribute>) {
return getDest(); return getDest();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CallOp
//===----------------------------------------------------------------------===//
LogicalResult CallOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
// Check that the callee attribute was specified.
auto fnAttr = (*this)->getAttrOfType<FlatSymbolRefAttr>("callee");
if (!fnAttr)
return emitOpError("requires a 'callee' symbol reference attribute");
FuncOp fn = symbolTable.lookupNearestSymbolFrom<FuncOp>(*this, fnAttr);
if (!fn)
return emitOpError() << "'" << fnAttr.getValue()
<< "' does not reference a valid function";
// Verify that the operand and result types match the callee.
auto fnType = fn.getType();
if (fnType.getNumInputs() != getNumOperands())
return emitOpError("incorrect number of operands for callee");
for (unsigned i = 0, e = fnType.getNumInputs(); i != e; ++i)
if (getOperand(i).getType() != fnType.getInput(i))
return emitOpError("operand type mismatch: expected operand type ")
<< fnType.getInput(i) << ", but provided "
<< getOperand(i).getType() << " for operand number " << i;
if (fnType.getNumResults() != getNumResults())
return emitOpError("incorrect number of results for callee");
for (unsigned i = 0, e = fnType.getNumResults(); i != e; ++i)
if (getResult(i).getType() != fnType.getResult(i)) {
auto diag = emitOpError("result type mismatch at index ") << i;
diag.attachNote() << " op result types: " << getResultTypes();
diag.attachNote() << "function result types: " << fnType.getResults();
return diag;
}
return success();
}
FunctionType CallOp::getCalleeType() {
return FunctionType::get(getContext(), getOperandTypes(), getResultTypes());
}
//===----------------------------------------------------------------------===//
// CallIndirectOp
//===----------------------------------------------------------------------===//
/// Fold indirect calls that have a constant function as the callee operand.
LogicalResult CallIndirectOp::canonicalize(CallIndirectOp indirectCall,
PatternRewriter &rewriter) {
// Check that the callee is a constant callee.
SymbolRefAttr calledFn;
if (!matchPattern(indirectCall.getCallee(), m_Constant(&calledFn)))
return failure();
// Replace with a direct call.
rewriter.replaceOpWithNewOp<CallOp>(indirectCall, calledFn,
indirectCall.getResultTypes(),
indirectCall.getArgOperands());
return success();
}
//===----------------------------------------------------------------------===//
// CondBranchOp // CondBranchOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
namespace { namespace {
/// cond_br true, ^bb1, ^bb2 /// cf.cond_br true, ^bb1, ^bb2
/// -> br ^bb1 /// -> br ^bb1
/// cond_br false, ^bb1, ^bb2 /// cf.cond_br false, ^bb1, ^bb2
/// -> br ^bb2 /// -> br ^bb2
/// ///
struct SimplifyConstCondBranchPred : public OpRewritePattern<CondBranchOp> { struct SimplifyConstCondBranchPred : public OpRewritePattern<CondBranchOp> {
using OpRewritePattern<CondBranchOp>::OpRewritePattern; using OpRewritePattern<CondBranchOp>::OpRewritePattern;
LogicalResult matchAndRewrite(CondBranchOp condbr, LogicalResult matchAndRewrite(CondBranchOp condbr,
PatternRewriter &rewriter) const override { PatternRewriter &rewriter) const override {
if (matchPattern(condbr.getCondition(), m_NonZero())) { if (matchPattern(condbr.getCondition(), m_NonZero())) {
// True branch taken. // True branch taken.
rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.getTrueDest(), rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.getTrueDest(),
condbr.getTrueOperands()); condbr.getTrueOperands());
return success(); return success();
} }
if (matchPattern(condbr.getCondition(), m_Zero())) { if (matchPattern(condbr.getCondition(), m_Zero())) {
// False branch taken. // False branch taken.
rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.getFalseDest(), rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.getFalseDest(),
condbr.getFalseOperands()); condbr.getFalseOperands());
return success(); return success();
} }
return failure(); return failure();
} }
}; };
/// cond_br %cond, ^bb1, ^bb2 /// cf.cond_br %cond, ^bb1, ^bb2
/// ^bb1 /// ^bb1
/// br ^bbN(...) /// br ^bbN(...)
/// ^bb2 /// ^bb2
/// br ^bbK(...) /// br ^bbK(...)
/// ///
/// -> cond_br %cond, ^bbN(...), ^bbK(...) /// -> cf.cond_br %cond, ^bbN(...), ^bbK(...)
/// ///
struct SimplifyPassThroughCondBranch : public OpRewritePattern<CondBranchOp> { struct SimplifyPassThroughCondBranch : public OpRewritePattern<CondBranchOp> {
using OpRewritePattern<CondBranchOp>::OpRewritePattern; using OpRewritePattern<CondBranchOp>::OpRewritePattern;
LogicalResult matchAndRewrite(CondBranchOp condbr, LogicalResult matchAndRewrite(CondBranchOp condbr,
PatternRewriter &rewriter) const override { PatternRewriter &rewriter) const override {
Block *trueDest = condbr.getTrueDest(), *falseDest = condbr.getFalseDest(); Block *trueDest = condbr.getTrueDest(), *falseDest = condbr.getFalseDest();
ValueRange trueDestOperands = condbr.getTrueOperands(); ValueRange trueDestOperands = condbr.getTrueOperands();
Show All 11 Lines LogicalResult matchAndRewrite(CondBranchOp condbr,
// Create a new branch with the collapsed successors. // Create a new branch with the collapsed successors.
rewriter.replaceOpWithNewOp<CondBranchOp>(condbr, condbr.getCondition(), rewriter.replaceOpWithNewOp<CondBranchOp>(condbr, condbr.getCondition(),
trueDest, trueDestOperands, trueDest, trueDestOperands,
falseDest, falseDestOperands); falseDest, falseDestOperands);
return success(); return success();
} }
}; };
/// cond_br %cond, ^bb1(A, ..., N), ^bb1(A, ..., N) /// cf.cond_br %cond, ^bb1(A, ..., N), ^bb1(A, ..., N)
/// -> br ^bb1(A, ..., N) /// -> br ^bb1(A, ..., N)
/// ///
/// cond_br %cond, ^bb1(A), ^bb1(B) /// cf.cond_br %cond, ^bb1(A), ^bb1(B)
/// -> %select = arith.select %cond, A, B /// -> %select = arith.select %cond, A, B
/// br ^bb1(%select) /// br ^bb1(%select)
/// ///
struct SimplifyCondBranchIdenticalSuccessors struct SimplifyCondBranchIdenticalSuccessors
: public OpRewritePattern<CondBranchOp> { : public OpRewritePattern<CondBranchOp> {
using OpRewritePattern<CondBranchOp>::OpRewritePattern; using OpRewritePattern<CondBranchOp>::OpRewritePattern;
LogicalResult matchAndRewrite(CondBranchOp condbr, LogicalResult matchAndRewrite(CondBranchOp condbr,
Show All 30 Lines LogicalResult matchAndRewrite(CondBranchOp condbr,
} }
rewriter.replaceOpWithNewOp<BranchOp>(condbr, trueDest, mergedOperands); rewriter.replaceOpWithNewOp<BranchOp>(condbr, trueDest, mergedOperands);
return success(); return success();
} }
}; };
/// ... /// ...
/// cond_br %cond, ^bb1(...), ^bb2(...) /// cf.cond_br %cond, ^bb1(...), ^bb2(...)
/// ... /// ...
/// ^bb1: // has single predecessor /// ^bb1: // has single predecessor
/// ... /// ...
/// cond_br %cond, ^bb3(...), ^bb4(...) /// cf.cond_br %cond, ^bb3(...), ^bb4(...)
/// ///
/// -> /// ->
/// ///
/// ... /// ...
/// cond_br %cond, ^bb1(...), ^bb2(...) /// cf.cond_br %cond, ^bb1(...), ^bb2(...)
/// ... /// ...
/// ^bb1: // has single predecessor /// ^bb1: // has single predecessor
/// ... /// ...
/// br ^bb3(...) /// br ^bb3(...)
/// ///
struct SimplifyCondBranchFromCondBranchOnSameCondition struct SimplifyCondBranchFromCondBranchOnSameCondition
: public OpRewritePattern<CondBranchOp> { : public OpRewritePattern<CondBranchOp> {
using OpRewritePattern<CondBranchOp>::OpRewritePattern; using OpRewritePattern<CondBranchOp>::OpRewritePattern;
Show All 18 Lines if (currentBlock == predBranch.getTrueDest())
condbr.getTrueDestOperands()); condbr.getTrueDestOperands());
else else
rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.getFalseDest(), rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.getFalseDest(),
condbr.getFalseDestOperands()); condbr.getFalseDestOperands());
return success(); return success();
} }
}; };
/// cond_br %arg0, ^trueB, ^falseB /// cf.cond_br %arg0, ^trueB, ^falseB
/// ///
/// ^trueB: /// ^trueB:
/// "test.consumer1"(%arg0) : (i1) -> () /// "test.consumer1"(%arg0) : (i1) -> ()
/// ... /// ...
/// ///
/// ^falseB: /// ^falseB:
/// "test.consumer2"(%arg0) : (i1) -> () /// "test.consumer2"(%arg0) : (i1) -> ()
/// ... /// ...
/// ///
/// -> /// ->
/// ///
/// cond_br %arg0, ^trueB, ^falseB /// cf.cond_br %arg0, ^trueB, ^falseB
/// ^trueB: /// ^trueB:
/// "test.consumer1"(%true) : (i1) -> () /// "test.consumer1"(%true) : (i1) -> ()
/// ... /// ...
/// ///
/// ^falseB: /// ^falseB:
/// "test.consumer2"(%false) : (i1) -> () /// "test.consumer2"(%false) : (i1) -> ()
/// ... /// ...
struct CondBranchTruthPropagation : public OpRewritePattern<CondBranchOp> { struct CondBranchTruthPropagation : public OpRewritePattern<CondBranchOp> {
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
Block *CondBranchOp::getSuccessorForOperands(ArrayRef<Attribute> operands) { Block *CondBranchOp::getSuccessorForOperands(ArrayRef<Attribute> operands) {
if (IntegerAttr condAttr = operands.front().dyn_cast_or_null<IntegerAttr>()) if (IntegerAttr condAttr = operands.front().dyn_cast_or_null<IntegerAttr>())
return condAttr.getValue().isOneValue() ? getTrueDest() : getFalseDest(); return condAttr.getValue().isOneValue() ? getTrueDest() : getFalseDest();
return nullptr; return nullptr;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ConstantOp
//===----------------------------------------------------------------------===//
LogicalResult ConstantOp::verify() {
StringRef fnName = getValue();
Type type = getType();
// Try to find the referenced function.
auto fn = (*this)->getParentOfType<ModuleOp>().lookupSymbol<FuncOp>(fnName);
if (!fn)
return emitOpError() << "reference to undefined function '" << fnName
<< "'";
// Check that the referenced function has the correct type.
if (fn.getType() != type)
return emitOpError("reference to function with mismatched type");
return success();
}
OpFoldResult ConstantOp::fold(ArrayRef<Attribute> operands) {
assert(operands.empty() && "constant has no operands");
return getValueAttr();
}
void ConstantOp::getAsmResultNames(
function_ref<void(Value, StringRef)> setNameFn) {
setNameFn(getResult(), "f");
}
bool ConstantOp::isBuildableWith(Attribute value, Type type) {
return value.isa<FlatSymbolRefAttr>() && type.isa<FunctionType>();
}
//===----------------------------------------------------------------------===//
// ReturnOp
//===----------------------------------------------------------------------===//
LogicalResult ReturnOp::verify() {
auto function = cast<FuncOp>((*this)->getParentOp());
// The operand number and types must match the function signature.
const auto &results = function.getType().getResults();
if (getNumOperands() != results.size())
return emitOpError("has ")
<< getNumOperands() << " operands, but enclosing function (@"
<< function.getName() << ") returns " << results.size();
for (unsigned i = 0, e = results.size(); i != e; ++i)
if (getOperand(i).getType() != results[i])
return emitError() << "type of return operand " << i << " ("
<< getOperand(i).getType()
<< ") doesn't match function result type ("
<< results[i] << ")"
<< " in function @" << function.getName();
return success();
}
//===----------------------------------------------------------------------===//
// SwitchOp // SwitchOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void SwitchOp::build(OpBuilder &builder, OperationState &result, Value value, void SwitchOp::build(OpBuilder &builder, OperationState &result, Value value,
Block *defaultDestination, ValueRange defaultOperands, Block *defaultDestination, ValueRange defaultOperands,
DenseIntElementsAttr caseValues, DenseIntElementsAttr caseValues,
BlockRange caseDestinations, BlockRange caseDestinations,
ArrayRef<ValueRange> caseOperands) { ArrayRef<ValueRange> caseOperands) {
▲ Show 20 Lines • Show All 421 Lines • ▼ Show 20 Lines results.add(&simplifySwitchWithOnlyDefault)
.add(&simplifySwitchFromDefaultSwitchOnSameCondition); .add(&simplifySwitchFromDefaultSwitchOnSameCondition);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TableGen'd op method definitions // TableGen'd op method definitions
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "mlir/Dialect/StandardOps/IR/Ops.cpp.inc" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.cpp.inc"

mlir/lib/Dialect/GPU/Transforms/AllReduceLowering.cpp

//===- AllReduceLowering.cpp - Implementation of all-reduce lowering ------===// //===- AllReduceLowering.cpp - Implementation of all-reduce lowering ------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements in-dialect lowering of the all-reduce op to a block of // This file implements in-dialect lowering of the all-reduce op to a block of
// simpler instructions. // simpler instructions.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.h"
#include "mlir/Dialect/GPU/Passes.h" #include "mlir/Dialect/GPU/Passes.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
Show All 12 Linesstruct GpuAllReduceRewriter {
/// ///
/// First reduce the elements within a subgroup. The first invocation of each /// First reduce the elements within a subgroup. The first invocation of each
/// subgroup writes the intermediate result to workgroup memory. After /// subgroup writes the intermediate result to workgroup memory. After
/// synchronizing the workgroup, the first subgroup reduces the values from /// synchronizing the workgroup, the first subgroup reduces the values from
/// workgroup memory. The result is broadcasted to all invocations through /// workgroup memory. The result is broadcasted to all invocations through
/// workgroup memory. /// workgroup memory.
/// ///
/// %subgroup_reduce = `createSubgroupReduce(%operand)` /// %subgroup_reduce = `createSubgroupReduce(%operand)`
/// cond_br %is_first_lane, ^then1, ^continue1 /// cf.cond_br %is_first_lane, ^then1, ^continue1
/// ^then1: /// ^then1:
/// store %subgroup_reduce, %workgroup_buffer[%subgroup_id] /// store %subgroup_reduce, %workgroup_buffer[%subgroup_id]
/// br ^continue1 /// cf.br ^continue1
/// ^continue1: /// ^continue1:
/// gpu.barrier /// gpu.barrier
/// %is_valid_subgroup = arith.cmpi "slt" %invocation_idx, %num_subgroups /// %is_valid_subgroup = arith.cmpi "slt" %invocation_idx, %num_subgroups
/// cond_br %is_valid_subgroup, ^then2, ^continue2 /// cf.cond_br %is_valid_subgroup, ^then2, ^continue2
/// ^then2: /// ^then2:
/// %partial_reduce = load %workgroup_buffer[%invocation_idx] /// %partial_reduce = load %workgroup_buffer[%invocation_idx]
/// %all_reduce = `createSubgroupReduce(%partial_reduce)` /// %all_reduce = `createSubgroupReduce(%partial_reduce)`
/// store %all_reduce, %workgroup_buffer[%zero] /// store %all_reduce, %workgroup_buffer[%zero]
/// llvm.br ^continue2 /// llvm.br ^continue2
/// ^continue2: /// ^continue2:
/// gpu.barrier /// gpu.barrier
/// %result = load %workgroup_buffer[%zero] /// %result = load %workgroup_buffer[%zero]
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 Lines return AccumulatorFactory([&](Value lhs, Value rhs) {
BlockAndValueMapping mapping; BlockAndValueMapping mapping;
mapping.map(body.getArgument(0), lhs); mapping.map(body.getArgument(0), lhs);
mapping.map(body.getArgument(1), rhs); mapping.map(body.getArgument(1), rhs);
rewriter.cloneRegionBefore(body, *split->getParent(), rewriter.cloneRegionBefore(body, *split->getParent(),
split->getIterator(), mapping); split->getIterator(), mapping);
// Add branch before inserted body, into body. // Add branch before inserted body, into body.
block = block->getNextNode(); block = block->getNextNode();
create<BranchOp>(block, ValueRange()); create<cf::BranchOp>(block, ValueRange());
// Replace all gpu.yield ops with branch out of body. // Replace all gpu.yield ops with branch out of body.
for (; block != split; block = block->getNextNode()) { for (; block != split; block = block->getNextNode()) {
Operation *terminator = block->getTerminator(); Operation *terminator = block->getTerminator();
if (!isa<gpu::YieldOp>(terminator)) if (!isa<gpu::YieldOp>(terminator))
continue; continue;
rewriter.setInsertionPointToEnd(block); rewriter.setInsertionPointToEnd(block);
rewriter.replaceOpWithNewOp<BranchOp>( rewriter.replaceOpWithNewOp<cf::BranchOp>(
terminator, split, ValueRange(terminator->getOperand(0))); terminator, split, ValueRange(terminator->getOperand(0)));
} }
// Return accumulator result. // Return accumulator result.
rewriter.setInsertionPointToStart(split); rewriter.setInsertionPointToStart(split);
return split->addArgument(lhs.getType(), lhs.getLoc()); return split->addArgument(lhs.getType(), lhs.getLoc());
}); });
} }
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines void createIf(Value condition, ThenOpsFactory &&thenOpsFactory,
Block *currentBlock = rewriter.getInsertionBlock(); Block *currentBlock = rewriter.getInsertionBlock();
auto currentPoint = rewriter.getInsertionPoint(); auto currentPoint = rewriter.getInsertionPoint();
Block *thenBlock = rewriter.splitBlock(currentBlock, currentPoint); Block *thenBlock = rewriter.splitBlock(currentBlock, currentPoint);
Block *elseBlock = rewriter.splitBlock(thenBlock, thenBlock->begin()); Block *elseBlock = rewriter.splitBlock(thenBlock, thenBlock->begin());
Block *continueBlock = rewriter.splitBlock(elseBlock, elseBlock->begin()); Block *continueBlock = rewriter.splitBlock(elseBlock, elseBlock->begin());
rewriter.setInsertionPointToEnd(currentBlock); rewriter.setInsertionPointToEnd(currentBlock);
create<CondBranchOp>(condition, thenBlock, create<cf::CondBranchOp>(condition, thenBlock,
/*trueOperands=*/ArrayRef<Value>(), elseBlock, /*trueOperands=*/ArrayRef<Value>(), elseBlock,
/*falseOperands=*/ArrayRef<Value>()); /*falseOperands=*/ArrayRef<Value>());
rewriter.setInsertionPointToStart(thenBlock); rewriter.setInsertionPointToStart(thenBlock);
auto thenOperands = thenOpsFactory(); auto thenOperands = thenOpsFactory();
create<BranchOp>(continueBlock, thenOperands); create<cf::BranchOp>(continueBlock, thenOperands);
rewriter.setInsertionPointToStart(elseBlock); rewriter.setInsertionPointToStart(elseBlock);
auto elseOperands = elseOpsFactory(); auto elseOperands = elseOpsFactory();
create<BranchOp>(continueBlock, elseOperands); create<cf::BranchOp>(continueBlock, elseOperands);
assert(thenOperands.size() == elseOperands.size()); assert(thenOperands.size() == elseOperands.size());
rewriter.setInsertionPointToStart(continueBlock); rewriter.setInsertionPointToStart(continueBlock);
for (auto operand : thenOperands) for (auto operand : thenOperands)
continueBlock->addArgument(operand.getType(), operand.getLoc()); continueBlock->addArgument(operand.getType(), operand.getLoc());
} }
/// Shortcut for createIf with empty else block and no block operands. /// Shortcut for createIf with empty else block and no block operands.
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

mlir/lib/Dialect/GPU/Transforms/KernelOutlining.cpp

//===- KernelOutlining.cpp - Implementation of GPU kernel outlining -------===// //===- KernelOutlining.cpp - Implementation of GPU kernel outlining -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the GPU dialect kernel outlining pass. // This file implements the GPU dialect kernel outlining pass.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PassDetail.h" #include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/DLTI/DLTI.h" #include "mlir/Dialect/DLTI/DLTI.h"
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.h"
#include "mlir/Dialect/GPU/Passes.h" #include "mlir/Dialect/GPU/Passes.h"
#include "mlir/Dialect/GPU/Utils.h" #include "mlir/Dialect/GPU/Utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
▲ Show 20 Lines • Show All 158 Lines • ▼ Show 20 Linesstatic gpu::GPUFuncOp outlineKernelFuncImpl(gpu::LaunchOp launchOp,
// cleaner. // cleaner.
launchOpBody.cloneInto(&outlinedFuncBody, map); launchOpBody.cloneInto(&outlinedFuncBody, map);
// Branch from entry of the gpu.func operation to the block that is cloned // Branch from entry of the gpu.func operation to the block that is cloned
// from the entry block of the gpu.launch operation. // from the entry block of the gpu.launch operation.
Block &launchOpEntry = launchOpBody.front(); Block &launchOpEntry = launchOpBody.front();
Block *clonedLaunchOpEntry = map.lookup(&launchOpEntry); Block *clonedLaunchOpEntry = map.lookup(&launchOpEntry);
builder.setInsertionPointToEnd(&entryBlock); builder.setInsertionPointToEnd(&entryBlock);
builder.create<BranchOp>(loc, clonedLaunchOpEntry); builder.create<cf::BranchOp>(loc, clonedLaunchOpEntry);
outlinedFunc.walk([](gpu::TerminatorOp op) { outlinedFunc.walk([](gpu::TerminatorOp op) {
OpBuilder replacer(op); OpBuilder replacer(op);
replacer.create<gpu::ReturnOp>(op.getLoc()); replacer.create<gpu::ReturnOp>(op.getLoc());
op.erase(); op.erase();
}); });
return outlinedFunc; return outlinedFunc;
} }
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/Detensorize.cpp

//===- Detensorize.cpp - Linalg transformations as patterns ----------===// //===- Detensorize.cpp - Linalg transformations as patterns ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PassDetail.h" #include "PassDetail.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/StandardOps/Transforms/FuncConversions.h" #include "mlir/Dialect/StandardOps/Transforms/FuncConversions.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/OpDefinition.h" #include "mlir/IR/OpDefinition.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include <iterator> #include <iterator>
▲ Show 20 Lines • Show All 231 Lines • ▼ Show 20 Linesstruct LinalgDetensorize : public LinalgDetensorizeBase<LinalgDetensorize> {
class ControlFlowDetectionModel : public CostModel { class ControlFlowDetectionModel : public CostModel {
public: public:
void compute(FunctionOpInterface func, void compute(FunctionOpInterface func,
DetensorizeTypeConverter typeConverter, DetensorizeTypeConverter typeConverter,
DenseSet<Operation *> &opsToDetensor, DenseSet<Operation *> &opsToDetensor,
DenseSet<BlockArgument> &blockArgsToDetensor) override { DenseSet<BlockArgument> &blockArgsToDetensor) override {
SmallVector<Value> workList; SmallVector<Value> workList;
func->walk([&](CondBranchOp condBr) { func->walk([&](cf::CondBranchOp condBr) {
for (auto operand : condBr.getOperands()) { for (auto operand : condBr.getOperands()) {
workList.push_back(operand); workList.push_back(operand);
} }
}); });
func->walk([&](BranchOp br) { func->walk([&](cf::BranchOp br) {
for (auto operand : br.getOperands()) { for (auto operand : br.getOperands()) {
workList.push_back(operand); workList.push_back(operand);
} }
}); });
DenseSet<Value> visitedValues; DenseSet<Value> visitedValues;
DenseSet<Operation *> visitedOps; DenseSet<Operation *> visitedOps;
▲ Show 20 Lines • Show All 294 Lines • Show Last 20 Lines

mlir/lib/Dialect/SCF/SCF.cpp

//===- SCF.cpp - Structured Control Flow Operations -----------------------===// //===- SCF.cpp - Structured Control Flow Operations -----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Support/MathExtras.h" #include "mlir/Support/MathExtras.h"
#include "mlir/Transforms/InliningUtils.h" #include "mlir/Transforms/InliningUtils.h"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 140 Lines • ▼ Show 20 Lines
}; };
// Inline an ExecuteRegionOp if its parent can contain multiple blocks. // Inline an ExecuteRegionOp if its parent can contain multiple blocks.
// TODO generalize the conditions for operations which can be inlined into. // TODO generalize the conditions for operations which can be inlined into.
// func @func_execute_region_elim() { // func @func_execute_region_elim() {
// "test.foo"() : () -> () // "test.foo"() : () -> ()
// %v = scf.execute_region -> i64 { // %v = scf.execute_region -> i64 {
// %c = "test.cmp"() : () -> i1 // %c = "test.cmp"() : () -> i1
// cond_br %c, ^bb2, ^bb3 // cf.cond_br %c, ^bb2, ^bb3
// ^bb2: // ^bb2:
// %x = "test.val1"() : () -> i64 // %x = "test.val1"() : () -> i64
// br ^bb4(%x : i64) // cf.br ^bb4(%x : i64)
// ^bb3: // ^bb3:
// %y = "test.val2"() : () -> i64 // %y = "test.val2"() : () -> i64
// br ^bb4(%y : i64) // cf.br ^bb4(%y : i64)
// ^bb4(%z : i64): // ^bb4(%z : i64):
// scf.yield %z : i64 // scf.yield %z : i64
// } // }
// "test.bar"(%v) : (i64) -> () // "test.bar"(%v) : (i64) -> ()
// return // return
// } // }
// //
// becomes // becomes
// //
// func @func_execute_region_elim() { // func @func_execute_region_elim() {
// "test.foo"() : () -> () // "test.foo"() : () -> ()
// %c = "test.cmp"() : () -> i1 // %c = "test.cmp"() : () -> i1
// cond_br %c, ^bb1, ^bb2 // cf.cond_br %c, ^bb1, ^bb2
// ^bb1: // pred: ^bb0 // ^bb1: // pred: ^bb0
// %x = "test.val1"() : () -> i64 // %x = "test.val1"() : () -> i64
// br ^bb3(%x : i64) // cf.br ^bb3(%x : i64)
// ^bb2: // pred: ^bb0 // ^bb2: // pred: ^bb0
// %y = "test.val2"() : () -> i64 // %y = "test.val2"() : () -> i64
// br ^bb3(%y : i64) // cf.br ^bb3(%y : i64)
// ^bb3(%z: i64): // 2 preds: ^bb1, ^bb2 // ^bb3(%z: i64): // 2 preds: ^bb1, ^bb2
// "test.bar"(%z) : (i64) -> () // "test.bar"(%z) : (i64) -> ()
// return // return
// } // }
// //
struct MultiBlockExecuteInliner : public OpRewritePattern<ExecuteRegionOp> { struct MultiBlockExecuteInliner : public OpRewritePattern<ExecuteRegionOp> {
using OpRewritePattern<ExecuteRegionOp>::OpRewritePattern; using OpRewritePattern<ExecuteRegionOp>::OpRewritePattern;
LogicalResult matchAndRewrite(ExecuteRegionOp op, LogicalResult matchAndRewrite(ExecuteRegionOp op,
PatternRewriter &rewriter) const override { PatternRewriter &rewriter) const override {
if (!isa<FuncOp, ExecuteRegionOp>(op->getParentOp())) if (!isa<FuncOp, ExecuteRegionOp>(op->getParentOp()))
return failure(); return failure();
Block *prevBlock = op->getBlock(); Block *prevBlock = op->getBlock();
Block *postBlock = rewriter.splitBlock(prevBlock, op->getIterator()); Block *postBlock = rewriter.splitBlock(prevBlock, op->getIterator());
rewriter.setInsertionPointToEnd(prevBlock); rewriter.setInsertionPointToEnd(prevBlock);
rewriter.create<BranchOp>(op.getLoc(), &op.getRegion().front()); rewriter.create<cf::BranchOp>(op.getLoc(), &op.getRegion().front());
for (Block &blk : op.getRegion()) { for (Block &blk : op.getRegion()) {
if (YieldOp yieldOp = dyn_cast<YieldOp>(blk.getTerminator())) { if (YieldOp yieldOp = dyn_cast<YieldOp>(blk.getTerminator())) {
rewriter.setInsertionPoint(yieldOp); rewriter.setInsertionPoint(yieldOp);
rewriter.create<BranchOp>(yieldOp.getLoc(), postBlock, rewriter.create<cf::BranchOp>(yieldOp.getLoc(), postBlock,
yieldOp.getResults()); yieldOp.getResults());
rewriter.eraseOp(yieldOp); rewriter.eraseOp(yieldOp);
} }
} }
rewriter.inlineRegionBefore(op.getRegion(), postBlock); rewriter.inlineRegionBefore(op.getRegion(), postBlock);
SmallVector<Value> blockArgs; SmallVector<Value> blockArgs;
for (auto res : op.getResults()) for (auto res : op.getResults())
▲ Show 20 Lines • Show All 2,631 Lines • Show Last 20 Lines

mlir/lib/Dialect/SparseTensor/Pipelines/CMakeLists.txt

add_mlir_dialect_library(MLIRSparseTensorPipelines add_mlir_dialect_library(MLIRSparseTensorPipelines
SparseTensorPipelines.cpp SparseTensorPipelines.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SparseTensor ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SparseTensor
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticTransforms MLIRArithmeticTransforms
MLIRAffineToStandard MLIRAffineToStandard
MLIRBufferizationTransforms MLIRBufferizationTransforms
MLIRLinalgTransforms MLIRLinalgTransforms
MLIRMathToLLVM MLIRMathToLLVM
MLIRMemRefToLLVM MLIRMemRefToLLVM
MLIRPass MLIRPass
MLIRReconcileUnrealizedCasts MLIRReconcileUnrealizedCasts
MLIRSCFToStandard MLIRSCFToControlFlow
MLIRSparseTensor MLIRSparseTensor
MLIRSparseTensorTransforms MLIRSparseTensorTransforms
MLIRStandardOpsTransforms MLIRStandardOpsTransforms
MLIRTensorTransforms MLIRTensorTransforms
MLIRVectorToLLVM MLIRVectorToLLVM
) )

mlir/lib/Dialect/SparseTensor/Pipelines/SparseTensorPipelines.cpp

Show All 27 Lines
void mlir::sparse_tensor::buildSparseCompiler( void mlir::sparse_tensor::buildSparseCompiler(
OpPassManager &pm, const SparseCompilerOptions &options) { OpPassManager &pm, const SparseCompilerOptions &options) {
// TODO(wrengr): ensure the original `pm` is for ModuleOp // TODO(wrengr): ensure the original `pm` is for ModuleOp
pm.addPass(createSparsificationPass(options.sparsificationOptions())); pm.addPass(createSparsificationPass(options.sparsificationOptions()));
pm.addPass(createSparseTensorConversionPass()); pm.addPass(createSparseTensorConversionPass());
pm.addNestedPass<FuncOp>(createLinalgBufferizePass()); pm.addNestedPass<FuncOp>(createLinalgBufferizePass());
pm.addNestedPass<FuncOp>(createConvertLinalgToLoopsPass()); pm.addNestedPass<FuncOp>(createConvertLinalgToLoopsPass());
pm.addNestedPass<FuncOp>(createConvertVectorToSCFPass()); pm.addNestedPass<FuncOp>(createConvertVectorToSCFPass());
pm.addPass(createLowerToCFGPass()); // --convert-scf-to-std pm.addNestedPass<FuncOp>(createConvertSCFToCFPass());
pm.addPass(createFuncBufferizePass()); pm.addPass(createFuncBufferizePass());
pm.addPass(arith::createConstantBufferizePass()); pm.addPass(arith::createConstantBufferizePass());
pm.addNestedPass<FuncOp>(createTensorBufferizePass()); pm.addNestedPass<FuncOp>(createTensorBufferizePass());
pm.addNestedPass<FuncOp>( pm.addNestedPass<FuncOp>(
mlir::bufferization::createFinalizingBufferizePass()); mlir::bufferization::createFinalizingBufferizePass());
pm.addPass(createLowerAffinePass()); pm.addPass(createLowerAffinePass());
pm.addPass(createConvertVectorToLLVMPass(options.lowerVectorToLLVMOptions())); pm.addPass(createConvertVectorToLLVMPass(options.lowerVectorToLLVMOptions()));
pm.addPass(createMemRefToLLVMPass()); pm.addPass(createMemRefToLLVMPass());
Show All 17 Lines

mlir/lib/Dialect/StandardOps/CMakeLists.txt

add_mlir_dialect_library(MLIRStandard add_mlir_dialect_library(MLIRStandard
IR/Ops.cpp IR/Ops.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/StandardOps ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/StandardOps
DEPENDS DEPENDS
MLIRStandardOpsIncGen MLIRStandardOpsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmetic MLIRArithmetic
MLIRCallInterfaces MLIRCallInterfaces
MLIRCastInterfaces MLIRCastInterfaces
MLIRControlFlow
MLIRControlFlowInterfaces MLIRControlFlowInterfaces
MLIRInferTypeOpInterface MLIRInferTypeOpInterface
MLIRIR MLIRIR
MLIRSideEffectInterfaces MLIRSideEffectInterfaces
MLIRVectorInterfaces MLIRVectorInterfaces
) )
add_subdirectory(Transforms) add_subdirectory(Transforms)

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

  • This file was copied to mlir/lib/Dialect/ControlFlow/IR/ControlFlowOps.cpp.
//===- Ops.cpp - Standard MLIR Operations ---------------------------------===// //===- Ops.cpp - Standard MLIR Operations ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
#include "mlir/Dialect/CommonFolders.h" #include "mlir/Dialect/CommonFolders.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/OpImplementation.h" #include "mlir/IR/OpImplementation.h"
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Linesstruct StdInlinerInterface : public DialectInlinerInterface {
void handleTerminator(Operation *op, Block *newDest) const final { void handleTerminator(Operation *op, Block *newDest) const final {
// Only "std.return" needs to be handled here. // Only "std.return" needs to be handled here.
auto returnOp = dyn_cast<ReturnOp>(op); auto returnOp = dyn_cast<ReturnOp>(op);
if (!returnOp) if (!returnOp)
return; return;
// Replace the return with a branch to the dest. // Replace the return with a branch to the dest.
OpBuilder builder(op); OpBuilder builder(op);
builder.create<BranchOp>(op->getLoc(), newDest, returnOp.getOperands()); builder.create<cf::BranchOp>(op->getLoc(), newDest, returnOp.getOperands());
op->erase(); op->erase();
} }
/// Handle the given inlined terminator by replacing it with a new operation /// Handle the given inlined terminator by replacing it with a new operation
/// as necessary. /// as necessary.
void handleTerminator(Operation *op, void handleTerminator(Operation *op,
ArrayRef<Value> valuesToRepl) const final { ArrayRef<Value> valuesToRepl) const final {
// Only "std.return" needs to be handled here. // Only "std.return" needs to be handled here.
Show All 28 Lines if (arith::ConstantOp::isBuildableWith(value, type))
return builder.create<arith::ConstantOp>(loc, type, value); return builder.create<arith::ConstantOp>(loc, type, value);
if (ConstantOp::isBuildableWith(value, type)) if (ConstantOp::isBuildableWith(value, type))
return builder.create<ConstantOp>(loc, type, return builder.create<ConstantOp>(loc, type,
value.cast<FlatSymbolRefAttr>()); value.cast<FlatSymbolRefAttr>());
return nullptr; return nullptr;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AssertOp
//===----------------------------------------------------------------------===//
LogicalResult AssertOp::canonicalize(AssertOp op, PatternRewriter &rewriter) {
// Erase assertion if argument is constant true.
if (matchPattern(op.getArg(), m_One())) {
rewriter.eraseOp(op);
return success();
}
return failure();
}
//===----------------------------------------------------------------------===//
// BranchOp
//===----------------------------------------------------------------------===//
/// Given a successor, try to collapse it to a new destination if it only
/// contains a passthrough unconditional branch. If the successor is
/// collapsable, `successor` and `successorOperands` are updated to reference
/// the new destination and values. `argStorage` is used as storage if operands
/// to the collapsed successor need to be remapped. It must outlive uses of
/// successorOperands.
static LogicalResult collapseBranch(Block *&successor,
ValueRange &successorOperands,
SmallVectorImpl<Value> &argStorage) {
// Check that the successor only contains a unconditional branch.
if (std::next(successor->begin()) != successor->end())
return failure();
// Check that the terminator is an unconditional branch.
BranchOp successorBranch = dyn_cast<BranchOp>(successor->getTerminator());
if (!successorBranch)
return failure();
// Check that the arguments are only used within the terminator.
for (BlockArgument arg : successor->getArguments()) {
for (Operation *user : arg.getUsers())
if (user != successorBranch)
return failure();
}
// Don't try to collapse branches to infinite loops.
Block *successorDest = successorBranch.getDest();
if (successorDest == successor)
return failure();
// Update the operands to the successor. If the branch parent has no
// arguments, we can use the branch operands directly.
OperandRange operands = successorBranch.getOperands();
if (successor->args_empty()) {
successor = successorDest;
successorOperands = operands;
return success();
}
// Otherwise, we need to remap any argument operands.
for (Value operand : operands) {
BlockArgument argOperand = operand.dyn_cast<BlockArgument>();
if (argOperand && argOperand.getOwner() == successor)
argStorage.push_back(successorOperands[argOperand.getArgNumber()]);
else
argStorage.push_back(operand);
}
successor = successorDest;
successorOperands = argStorage;
return success();
}
/// Simplify a branch to a block that has a single predecessor. This effectively
/// merges the two blocks.
static LogicalResult
simplifyBrToBlockWithSinglePred(BranchOp op, PatternRewriter &rewriter) {
// Check that the successor block has a single predecessor.
Block *succ = op.getDest();
Block *opParent = op->getBlock();
if (succ == opParent || !llvm::hasSingleElement(succ->getPredecessors()))
return failure();
// Merge the successor into the current block and erase the branch.
rewriter.mergeBlocks(succ, opParent, op.getOperands());
rewriter.eraseOp(op);
return success();
}
/// br ^bb1
/// ^bb1
/// br ^bbN(...)
///
/// -> br ^bbN(...)
///
static LogicalResult simplifyPassThroughBr(BranchOp op,
PatternRewriter &rewriter) {
Block *dest = op.getDest();
ValueRange destOperands = op.getOperands();
SmallVector<Value, 4> destOperandStorage;
// Try to collapse the successor if it points somewhere other than this
// block.
if (dest == op->getBlock() ||
failed(collapseBranch(dest, destOperands, destOperandStorage)))
return failure();
// Create a new branch with the collapsed successor.
rewriter.replaceOpWithNewOp<BranchOp>(op, dest, destOperands);
return success();
}
LogicalResult BranchOp::canonicalize(BranchOp op, PatternRewriter &rewriter) {
return success(succeeded(simplifyBrToBlockWithSinglePred(op, rewriter)) ||
succeeded(simplifyPassThroughBr(op, rewriter)));
}
void BranchOp::setDest(Block *block) { return setSuccessor(block); }
void BranchOp::eraseOperand(unsigned index) { (*this)->eraseOperand(index); }
Optional<MutableOperandRange>
BranchOp::getMutableSuccessorOperands(unsigned index) {
assert(index == 0 && "invalid successor index");
return getDestOperandsMutable();
}
Block *BranchOp::getSuccessorForOperands(ArrayRef<Attribute>) {
return getDest();
}
//===----------------------------------------------------------------------===//
// CallOp // CallOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
LogicalResult CallOp::verifySymbolUses(SymbolTableCollection &symbolTable) { LogicalResult CallOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
// Check that the callee attribute was specified. // Check that the callee attribute was specified.
auto fnAttr = (*this)->getAttrOfType<FlatSymbolRefAttr>("callee"); auto fnAttr = (*this)->getAttrOfType<FlatSymbolRefAttr>("callee");
if (!fnAttr) if (!fnAttr)
return emitOpError("requires a 'callee' symbol reference attribute"); return emitOpError("requires a 'callee' symbol reference attribute");
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 LinesLogicalResult CallIndirectOp::canonicalize(CallIndirectOp indirectCall,
// Replace with a direct call. // Replace with a direct call.
rewriter.replaceOpWithNewOp<CallOp>(indirectCall, calledFn, rewriter.replaceOpWithNewOp<CallOp>(indirectCall, calledFn,
indirectCall.getResultTypes(), indirectCall.getResultTypes(),
indirectCall.getArgOperands()); indirectCall.getArgOperands());
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CondBranchOp
//===----------------------------------------------------------------------===//
namespace {
/// cond_br true, ^bb1, ^bb2
/// -> br ^bb1
/// cond_br false, ^bb1, ^bb2
/// -> br ^bb2
///
struct SimplifyConstCondBranchPred : public OpRewritePattern<CondBranchOp> {
using OpRewritePattern<CondBranchOp>::OpRewritePattern;
LogicalResult matchAndRewrite(CondBranchOp condbr,
PatternRewriter &rewriter) const override {
if (matchPattern(condbr.getCondition(), m_NonZero())) {
// True branch taken.
rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.getTrueDest(),
condbr.getTrueOperands());
return success();
}
if (matchPattern(condbr.getCondition(), m_Zero())) {
// False branch taken.
rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.getFalseDest(),
condbr.getFalseOperands());
return success();
}
return failure();
}
};
/// cond_br %cond, ^bb1, ^bb2
/// ^bb1
/// br ^bbN(...)
/// ^bb2
/// br ^bbK(...)
///
/// -> cond_br %cond, ^bbN(...), ^bbK(...)
///
struct SimplifyPassThroughCondBranch : public OpRewritePattern<CondBranchOp> {
using OpRewritePattern<CondBranchOp>::OpRewritePattern;
LogicalResult matchAndRewrite(CondBranchOp condbr,
PatternRewriter &rewriter) const override {
Block *trueDest = condbr.getTrueDest(), *falseDest = condbr.getFalseDest();
ValueRange trueDestOperands = condbr.getTrueOperands();
ValueRange falseDestOperands = condbr.getFalseOperands();
SmallVector<Value, 4> trueDestOperandStorage, falseDestOperandStorage;
// Try to collapse one of the current successors.
LogicalResult collapsedTrue =
collapseBranch(trueDest, trueDestOperands, trueDestOperandStorage);
LogicalResult collapsedFalse =
collapseBranch(falseDest, falseDestOperands, falseDestOperandStorage);
if (failed(collapsedTrue) && failed(collapsedFalse))
return failure();
// Create a new branch with the collapsed successors.
rewriter.replaceOpWithNewOp<CondBranchOp>(condbr, condbr.getCondition(),
trueDest, trueDestOperands,
falseDest, falseDestOperands);
return success();
}
};
/// cond_br %cond, ^bb1(A, ..., N), ^bb1(A, ..., N)
/// -> br ^bb1(A, ..., N)
///
/// cond_br %cond, ^bb1(A), ^bb1(B)
/// -> %select = arith.select %cond, A, B
/// br ^bb1(%select)
///
struct SimplifyCondBranchIdenticalSuccessors
: public OpRewritePattern<CondBranchOp> {
using OpRewritePattern<CondBranchOp>::OpRewritePattern;
LogicalResult matchAndRewrite(CondBranchOp condbr,
PatternRewriter &rewriter) const override {
// Check that the true and false destinations are the same and have the same
// operands.
Block *trueDest = condbr.getTrueDest();
if (trueDest != condbr.getFalseDest())
return failure();
// If all of the operands match, no selects need to be generated.
OperandRange trueOperands = condbr.getTrueOperands();
OperandRange falseOperands = condbr.getFalseOperands();
if (trueOperands == falseOperands) {
rewriter.replaceOpWithNewOp<BranchOp>(condbr, trueDest, trueOperands);
return success();
}
// Otherwise, if the current block is the only predecessor insert selects
// for any mismatched branch operands.
if (trueDest->getUniquePredecessor() != condbr->getBlock())
return failure();
// Generate a select for any operands that differ between the two.
SmallVector<Value, 8> mergedOperands;
mergedOperands.reserve(trueOperands.size());
Value condition = condbr.getCondition();
for (auto it : llvm::zip(trueOperands, falseOperands)) {
if (std::get<0>(it) == std::get<1>(it))
mergedOperands.push_back(std::get<0>(it));
else
mergedOperands.push_back(rewriter.create<arith::SelectOp>(
condbr.getLoc(), condition, std::get<0>(it), std::get<1>(it)));
}
rewriter.replaceOpWithNewOp<BranchOp>(condbr, trueDest, mergedOperands);
return success();
}
};
/// ...
/// cond_br %cond, ^bb1(...), ^bb2(...)
/// ...
/// ^bb1: // has single predecessor
/// ...
/// cond_br %cond, ^bb3(...), ^bb4(...)
///
/// ->
///
/// ...
/// cond_br %cond, ^bb1(...), ^bb2(...)
/// ...
/// ^bb1: // has single predecessor
/// ...
/// br ^bb3(...)
///
struct SimplifyCondBranchFromCondBranchOnSameCondition
: public OpRewritePattern<CondBranchOp> {
using OpRewritePattern<CondBranchOp>::OpRewritePattern;
LogicalResult matchAndRewrite(CondBranchOp condbr,
PatternRewriter &rewriter) const override {
// Check that we have a single distinct predecessor.
Block *currentBlock = condbr->getBlock();
Block *predecessor = currentBlock->getSinglePredecessor();
if (!predecessor)
return failure();
// Check that the predecessor terminates with a conditional branch to this
// block and that it branches on the same condition.
auto predBranch = dyn_cast<CondBranchOp>(predecessor->getTerminator());
if (!predBranch || condbr.getCondition() != predBranch.getCondition())
return failure();
// Fold this branch to an unconditional branch.
if (currentBlock == predBranch.getTrueDest())
rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.getTrueDest(),
condbr.getTrueDestOperands());
else
rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.getFalseDest(),
condbr.getFalseDestOperands());
return success();
}
};
/// cond_br %arg0, ^trueB, ^falseB
///
/// ^trueB:
/// "test.consumer1"(%arg0) : (i1) -> ()
/// ...
///
/// ^falseB:
/// "test.consumer2"(%arg0) : (i1) -> ()
/// ...
///
/// ->
///
/// cond_br %arg0, ^trueB, ^falseB
/// ^trueB:
/// "test.consumer1"(%true) : (i1) -> ()
/// ...
///
/// ^falseB:
/// "test.consumer2"(%false) : (i1) -> ()
/// ...
struct CondBranchTruthPropagation : public OpRewritePattern<CondBranchOp> {
using OpRewritePattern<CondBranchOp>::OpRewritePattern;
LogicalResult matchAndRewrite(CondBranchOp condbr,
PatternRewriter &rewriter) const override {
// Check that we have a single distinct predecessor.
bool replaced = false;
Type ty = rewriter.getI1Type();
// These variables serve to prevent creating duplicate constants
// and hold constant true or false values.
Value constantTrue = nullptr;
Value constantFalse = nullptr;
// TODO These checks can be expanded to encompas any use with only
// either the true of false edge as a predecessor. For now, we fall
// back to checking the single predecessor is given by the true/fasle
// destination, thereby ensuring that only that edge can reach the
// op.
if (condbr.getTrueDest()->getSinglePredecessor()) {
for (OpOperand &use :
llvm::make_early_inc_range(condbr.getCondition().getUses())) {
if (use.getOwner()->getBlock() == condbr.getTrueDest()) {
replaced = true;
if (!constantTrue)
constantTrue = rewriter.create<arith::ConstantOp>(
condbr.getLoc(), ty, rewriter.getBoolAttr(true));
rewriter.updateRootInPlace(use.getOwner(),
[&] { use.set(constantTrue); });
}
}
}
if (condbr.getFalseDest()->getSinglePredecessor()) {
for (OpOperand &use :
llvm::make_early_inc_range(condbr.getCondition().getUses())) {
if (use.getOwner()->getBlock() == condbr.getFalseDest()) {
replaced = true;
if (!constantFalse)
constantFalse = rewriter.create<arith::ConstantOp>(
condbr.getLoc(), ty, rewriter.getBoolAttr(false));
rewriter.updateRootInPlace(use.getOwner(),
[&] { use.set(constantFalse); });
}
}
}
return success(replaced);
}
};
} // namespace
void CondBranchOp::getCanonicalizationPatterns(RewritePatternSet &results,
MLIRContext *context) {
results.add<SimplifyConstCondBranchPred, SimplifyPassThroughCondBranch,
SimplifyCondBranchIdenticalSuccessors,
SimplifyCondBranchFromCondBranchOnSameCondition,
CondBranchTruthPropagation>(context);
}
Optional<MutableOperandRange>
CondBranchOp::getMutableSuccessorOperands(unsigned index) {
assert(index < getNumSuccessors() && "invalid successor index");
return index == trueIndex ? getTrueDestOperandsMutable()
: getFalseDestOperandsMutable();
}
Block *CondBranchOp::getSuccessorForOperands(ArrayRef<Attribute> operands) {
if (IntegerAttr condAttr = operands.front().dyn_cast_or_null<IntegerAttr>())
return condAttr.getValue().isOneValue() ? getTrueDest() : getFalseDest();
return nullptr;
}
//===----------------------------------------------------------------------===//
// ConstantOp // ConstantOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
LogicalResult ConstantOp::verify() { LogicalResult ConstantOp::verify() {
StringRef fnName = getValue(); StringRef fnName = getValue();
Type type = getType(); Type type = getType();
// Try to find the referenced function. // Try to find the referenced function.
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines if (getOperand(i).getType() != results[i])
<< ") doesn't match function result type (" << ") doesn't match function result type ("
<< results[i] << ")" << results[i] << ")"
<< " in function @" << function.getName(); << " in function @" << function.getName();
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// SwitchOp
//===----------------------------------------------------------------------===//
void SwitchOp::build(OpBuilder &builder, OperationState &result, Value value,
Block *defaultDestination, ValueRange defaultOperands,
DenseIntElementsAttr caseValues,
BlockRange caseDestinations,
ArrayRef<ValueRange> caseOperands) {
build(builder, result, value, defaultOperands, caseOperands, caseValues,
defaultDestination, caseDestinations);
}
void SwitchOp::build(OpBuilder &builder, OperationState &result, Value value,
Block *defaultDestination, ValueRange defaultOperands,
ArrayRef<APInt> caseValues, BlockRange caseDestinations,
ArrayRef<ValueRange> caseOperands) {
DenseIntElementsAttr caseValuesAttr;
if (!caseValues.empty()) {
ShapedType caseValueType = VectorType::get(
static_cast<int64_t>(caseValues.size()), value.getType());
caseValuesAttr = DenseIntElementsAttr::get(caseValueType, caseValues);
}
build(builder, result, value, defaultDestination, defaultOperands,
caseValuesAttr, caseDestinations, caseOperands);
}
/// <cases> ::= `default` `:` bb-id (`(` ssa-use-and-type-list `)`)?
/// ( `,` integer `:` bb-id (`(` ssa-use-and-type-list `)`)? )*
static ParseResult parseSwitchOpCases(
OpAsmParser &parser, Type &flagType, Block *&defaultDestination,
SmallVectorImpl<OpAsmParser::OperandType> &defaultOperands,
SmallVectorImpl<Type> &defaultOperandTypes,
DenseIntElementsAttr &caseValues,
SmallVectorImpl<Block *> &caseDestinations,
SmallVectorImpl<SmallVector<OpAsmParser::OperandType>> &caseOperands,
SmallVectorImpl<SmallVector<Type>> &caseOperandTypes) {
if (parser.parseKeyword("default") || parser.parseColon() ||
parser.parseSuccessor(defaultDestination))
return failure();
if (succeeded(parser.parseOptionalLParen())) {
if (parser.parseRegionArgumentList(defaultOperands) ||
parser.parseColonTypeList(defaultOperandTypes) || parser.parseRParen())
return failure();
}
SmallVector<APInt> values;
unsigned bitWidth = flagType.getIntOrFloatBitWidth();
while (succeeded(parser.parseOptionalComma())) {
int64_t value = 0;
if (failed(parser.parseInteger(value)))
return failure();
values.push_back(APInt(bitWidth, value));
Block *destination;
SmallVector<OpAsmParser::OperandType> operands;
SmallVector<Type> operandTypes;
if (failed(parser.parseColon()) ||
failed(parser.parseSuccessor(destination)))
return failure();
if (succeeded(parser.parseOptionalLParen())) {
if (failed(parser.parseRegionArgumentList(operands)) ||
failed(parser.parseColonTypeList(operandTypes)) ||
failed(parser.parseRParen()))
return failure();
}
caseDestinations.push_back(destination);
caseOperands.emplace_back(operands);
caseOperandTypes.emplace_back(operandTypes);
}
if (!values.empty()) {
ShapedType caseValueType =
VectorType::get(static_cast<int64_t>(values.size()), flagType);
caseValues = DenseIntElementsAttr::get(caseValueType, values);
}
return success();
}
static void printSwitchOpCases(
OpAsmPrinter &p, SwitchOp op, Type flagType, Block *defaultDestination,
OperandRange defaultOperands, TypeRange defaultOperandTypes,
DenseIntElementsAttr caseValues, SuccessorRange caseDestinations,
OperandRangeRange caseOperands, const TypeRangeRange &caseOperandTypes) {
p << " default: ";
p.printSuccessorAndUseList(defaultDestination, defaultOperands);
if (!caseValues)
return;
for (const auto &it : llvm::enumerate(caseValues.getValues<APInt>())) {
p << ',';
p.printNewline();
p << " ";
p << it.value().getLimitedValue();
p << ": ";
p.printSuccessorAndUseList(caseDestinations[it.index()],
caseOperands[it.index()]);
}
p.printNewline();
}
LogicalResult SwitchOp::verify() {
auto caseValues = getCaseValues();
auto caseDestinations = getCaseDestinations();
if (!caseValues && caseDestinations.empty())
return success();
Type flagType = getFlag().getType();
Type caseValueType = caseValues->getType().getElementType();
if (caseValueType != flagType)
return emitOpError() << "'flag' type (" << flagType
<< ") should match case value type (" << caseValueType
<< ")";
if (caseValues &&
caseValues->size() != static_cast<int64_t>(caseDestinations.size()))
return emitOpError() << "number of case values (" << caseValues->size()
<< ") should match number of "
"case destinations ("
<< caseDestinations.size() << ")";
return success();
}
Optional<MutableOperandRange>
SwitchOp::getMutableSuccessorOperands(unsigned index) {
assert(index < getNumSuccessors() && "invalid successor index");
return index == 0 ? getDefaultOperandsMutable()
: getCaseOperandsMutable(index - 1);
}
Block *SwitchOp::getSuccessorForOperands(ArrayRef<Attribute> operands) {
Optional<DenseIntElementsAttr> caseValues = getCaseValues();
if (!caseValues)
return getDefaultDestination();
SuccessorRange caseDests = getCaseDestinations();
if (auto value = operands.front().dyn_cast_or_null<IntegerAttr>()) {
for (const auto &it : llvm::enumerate(caseValues->getValues<APInt>()))
if (it.value() == value.getValue())
return caseDests[it.index()];
return getDefaultDestination();
}
return nullptr;
}
/// switch %flag : i32, [
/// default: ^bb1
/// ]
/// -> br ^bb1
static LogicalResult simplifySwitchWithOnlyDefault(SwitchOp op,
PatternRewriter &rewriter) {
if (!op.getCaseDestinations().empty())
return failure();
rewriter.replaceOpWithNewOp<BranchOp>(op, op.getDefaultDestination(),
op.getDefaultOperands());
return success();
}
/// switch %flag : i32, [
/// default: ^bb1,
/// 42: ^bb1,
/// 43: ^bb2
/// ]
/// ->
/// switch %flag : i32, [
/// default: ^bb1,
/// 43: ^bb2
/// ]
static LogicalResult
dropSwitchCasesThatMatchDefault(SwitchOp op, PatternRewriter &rewriter) {
SmallVector<Block *> newCaseDestinations;
SmallVector<ValueRange> newCaseOperands;
SmallVector<APInt> newCaseValues;
bool requiresChange = false;
auto caseValues = op.getCaseValues();
auto caseDests = op.getCaseDestinations();
for (const auto &it : llvm::enumerate(caseValues->getValues<APInt>())) {
if (caseDests[it.index()] == op.getDefaultDestination() &&
op.getCaseOperands(it.index()) == op.getDefaultOperands()) {
requiresChange = true;
continue;
}
newCaseDestinations.push_back(caseDests[it.index()]);
newCaseOperands.push_back(op.getCaseOperands(it.index()));
newCaseValues.push_back(it.value());
}
if (!requiresChange)
return failure();
rewriter.replaceOpWithNewOp<SwitchOp>(
op, op.getFlag(), op.getDefaultDestination(), op.getDefaultOperands(),
newCaseValues, newCaseDestinations, newCaseOperands);
return success();
}
/// Helper for folding a switch with a constant value.
/// switch %c_42 : i32, [
/// default: ^bb1 ,
/// 42: ^bb2,
/// 43: ^bb3
/// ]
/// -> br ^bb2
static void foldSwitch(SwitchOp op, PatternRewriter &rewriter,
const APInt &caseValue) {
auto caseValues = op.getCaseValues();
for (const auto &it : llvm::enumerate(caseValues->getValues<APInt>())) {
if (it.value() == caseValue) {
rewriter.replaceOpWithNewOp<BranchOp>(
op, op.getCaseDestinations()[it.index()],
op.getCaseOperands(it.index()));
return;
}
}
rewriter.replaceOpWithNewOp<BranchOp>(op, op.getDefaultDestination(),
op.getDefaultOperands());
}
/// switch %c_42 : i32, [
/// default: ^bb1,
/// 42: ^bb2,
/// 43: ^bb3
/// ]
/// -> br ^bb2
static LogicalResult simplifyConstSwitchValue(SwitchOp op,
PatternRewriter &rewriter) {
APInt caseValue;
if (!matchPattern(op.getFlag(), m_ConstantInt(&caseValue)))
return failure();
foldSwitch(op, rewriter, caseValue);
return success();
}
/// switch %c_42 : i32, [
/// default: ^bb1,
/// 42: ^bb2,
/// ]
/// ^bb2:
/// br ^bb3
/// ->
/// switch %c_42 : i32, [
/// default: ^bb1,
/// 42: ^bb3,
/// ]
static LogicalResult simplifyPassThroughSwitch(SwitchOp op,
PatternRewriter &rewriter) {
SmallVector<Block *> newCaseDests;
SmallVector<ValueRange> newCaseOperands;
SmallVector<SmallVector<Value>> argStorage;
auto caseValues = op.getCaseValues();
auto caseDests = op.getCaseDestinations();
bool requiresChange = false;
for (int64_t i = 0, size = caseValues->size(); i < size; ++i) {
Block *caseDest = caseDests[i];
ValueRange caseOperands = op.getCaseOperands(i);
argStorage.emplace_back();
if (succeeded(collapseBranch(caseDest, caseOperands, argStorage.back())))
requiresChange = true;
newCaseDests.push_back(caseDest);
newCaseOperands.push_back(caseOperands);
}
Block *defaultDest = op.getDefaultDestination();
ValueRange defaultOperands = op.getDefaultOperands();
argStorage.emplace_back();
if (succeeded(
collapseBranch(defaultDest, defaultOperands, argStorage.back())))
requiresChange = true;
if (!requiresChange)
return failure();
rewriter.replaceOpWithNewOp<SwitchOp>(op, op.getFlag(), defaultDest,
defaultOperands, caseValues.getValue(),
newCaseDests, newCaseOperands);
return success();
}
/// switch %flag : i32, [
/// default: ^bb1,
/// 42: ^bb2,
/// ]
/// ^bb2:
/// switch %flag : i32, [
/// default: ^bb3,
/// 42: ^bb4
/// ]
/// ->
/// switch %flag : i32, [
/// default: ^bb1,
/// 42: ^bb2,
/// ]
/// ^bb2:
/// br ^bb4
///
/// and
///
/// switch %flag : i32, [
/// default: ^bb1,
/// 42: ^bb2,
/// ]
/// ^bb2:
/// switch %flag : i32, [
/// default: ^bb3,
/// 43: ^bb4
/// ]
/// ->
/// switch %flag : i32, [
/// default: ^bb1,
/// 42: ^bb2,
/// ]
/// ^bb2:
/// br ^bb3
static LogicalResult
simplifySwitchFromSwitchOnSameCondition(SwitchOp op,
PatternRewriter &rewriter) {
// Check that we have a single distinct predecessor.
Block *currentBlock = op->getBlock();
Block *predecessor = currentBlock->getSinglePredecessor();
if (!predecessor)
return failure();
// Check that the predecessor terminates with a switch branch to this block
// and that it branches on the same condition and that this branch isn't the
// default destination.
auto predSwitch = dyn_cast<SwitchOp>(predecessor->getTerminator());
if (!predSwitch || op.getFlag() != predSwitch.getFlag() ||
predSwitch.getDefaultDestination() == currentBlock)
return failure();
// Fold this switch to an unconditional branch.
SuccessorRange predDests = predSwitch.getCaseDestinations();
auto it = llvm::find(predDests, currentBlock);
if (it != predDests.end()) {
Optional<DenseIntElementsAttr> predCaseValues = predSwitch.getCaseValues();
foldSwitch(op, rewriter,
predCaseValues->getValues<APInt>()[it - predDests.begin()]);
} else {
rewriter.replaceOpWithNewOp<BranchOp>(op, op.getDefaultDestination(),
op.getDefaultOperands());
}
return success();
}
/// switch %flag : i32, [
/// default: ^bb1,
/// 42: ^bb2
/// ]
/// ^bb1:
/// switch %flag : i32, [
/// default: ^bb3,
/// 42: ^bb4,
/// 43: ^bb5
/// ]
/// ->
/// switch %flag : i32, [
/// default: ^bb1,
/// 42: ^bb2,
/// ]
/// ^bb1:
/// switch %flag : i32, [
/// default: ^bb3,
/// 43: ^bb5
/// ]
static LogicalResult
simplifySwitchFromDefaultSwitchOnSameCondition(SwitchOp op,
PatternRewriter &rewriter) {
// Check that we have a single distinct predecessor.
Block *currentBlock = op->getBlock();
Block *predecessor = currentBlock->getSinglePredecessor();
if (!predecessor)
return failure();
// Check that the predecessor terminates with a switch branch to this block
// and that it branches on the same condition and that this branch is the
// default destination.
auto predSwitch = dyn_cast<SwitchOp>(predecessor->getTerminator());
if (!predSwitch || op.getFlag() != predSwitch.getFlag() ||
predSwitch.getDefaultDestination() != currentBlock)
return failure();
// Delete case values that are not possible here.
DenseSet<APInt> caseValuesToRemove;
auto predDests = predSwitch.getCaseDestinations();
auto predCaseValues = predSwitch.getCaseValues();
for (int64_t i = 0, size = predCaseValues->size(); i < size; ++i)
if (currentBlock != predDests[i])
caseValuesToRemove.insert(predCaseValues->getValues<APInt>()[i]);
SmallVector<Block *> newCaseDestinations;
SmallVector<ValueRange> newCaseOperands;
SmallVector<APInt> newCaseValues;
bool requiresChange = false;
auto caseValues = op.getCaseValues();
auto caseDests = op.getCaseDestinations();
for (const auto &it : llvm::enumerate(caseValues->getValues<APInt>())) {
if (caseValuesToRemove.contains(it.value())) {
requiresChange = true;
continue;
}
newCaseDestinations.push_back(caseDests[it.index()]);
newCaseOperands.push_back(op.getCaseOperands(it.index()));
newCaseValues.push_back(it.value());
}
if (!requiresChange)
return failure();
rewriter.replaceOpWithNewOp<SwitchOp>(
op, op.getFlag(), op.getDefaultDestination(), op.getDefaultOperands(),
newCaseValues, newCaseDestinations, newCaseOperands);
return success();
}
void SwitchOp::getCanonicalizationPatterns(RewritePatternSet &results,
MLIRContext *context) {
results.add(&simplifySwitchWithOnlyDefault)
.add(&dropSwitchCasesThatMatchDefault)
.add(&simplifyConstSwitchValue)
.add(&simplifyPassThroughSwitch)
.add(&simplifySwitchFromSwitchOnSameCondition)
.add(&simplifySwitchFromDefaultSwitchOnSameCondition);
}
//===----------------------------------------------------------------------===//
// TableGen'd op method definitions // TableGen'd op method definitions
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "mlir/Dialect/StandardOps/IR/Ops.cpp.inc" #include "mlir/Dialect/StandardOps/IR/Ops.cpp.inc"

mlir/lib/Target/Cpp/TranslateRegistration.cpp

//===- TranslateRegistration.cpp - Register translation -------------------===// //===- TranslateRegistration.cpp - Register translation -------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
#include "mlir/Dialect/EmitC/IR/EmitC.h" #include "mlir/Dialect/EmitC/IR/EmitC.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/Target/Cpp/CppEmitter.h" #include "mlir/Target/Cpp/CppEmitter.h"
#include "mlir/Translation.h" #include "mlir/Translation.h"
Show All 18 Lines TranslateFromMLIRRegistration reg(
[](ModuleOp module, raw_ostream &output) { [](ModuleOp module, raw_ostream &output) {
return emitc::translateToCpp( return emitc::translateToCpp(
module, output, module, output,
/*declareVariablesAtTop=*/declareVariablesAtTop); /*declareVariablesAtTop=*/declareVariablesAtTop);
}, },
[](DialectRegistry &registry) { [](DialectRegistry &registry) {
// clang-format off // clang-format off
registry.insert<arith::ArithmeticDialect, registry.insert<arith::ArithmeticDialect,
cf::ControlFlowDialect,
emitc::EmitCDialect, emitc::EmitCDialect,
math::MathDialect, math::MathDialect,
StandardOpsDialect, StandardOpsDialect,
scf::SCFDialect>(); scf::SCFDialect>();
// clang-format on // clang-format on
}); });
} }
} // namespace mlir } // namespace mlir

mlir/lib/Target/Cpp/TranslateToCpp.cpp

//===- TranslateToCpp.cpp - Translating to C++ calls ----------------------===// //===- TranslateToCpp.cpp - Translating to C++ calls ----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <utility> #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/EmitC/IR/EmitC.h" #include "mlir/Dialect/EmitC/IR/EmitC.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/IR/Operation.h" #include "mlir/IR/Operation.h"
#include "mlir/Support/IndentedOstream.h" #include "mlir/Support/IndentedOstream.h"
#include "mlir/Target/Cpp/CppEmitter.h" #include "mlir/Target/Cpp/CppEmitter.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringMap.h"
#include "llvm/ADT/TypeSwitch.h" #include "llvm/ADT/TypeSwitch.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/FormatVariadic.h"
#include <utility>
stellaraccidentUnsubmitted
Done
ReplyInline Actions

Isn't this supposed to be sorted to a come first in a block by itself?

stellaraccident: Isn't this supposed to be sorted to a come first in a block by itself?
rriddleAuthorUnsubmitted
Done
ReplyInline Actions

No, system includes are supposed to come last:

https://llvm.org/docs/CodingStandards.html#include-style

rriddle: No, system includes are supposed to come last: https://llvm.org/docs/CodingStandards.
#define DEBUG_TYPE "translate-to-cpp" #define DEBUG_TYPE "translate-to-cpp"
using namespace mlir; using namespace mlir;
using namespace mlir::emitc; using namespace mlir::emitc;
using llvm::formatv; using llvm::formatv;
/// Convenience functions to produce interleaved output with functions returning /// Convenience functions to produce interleaved output with functions returning
▲ Show 20 Lines • Show All 198 Lines • ▼ Show 20 Lines
static LogicalResult printOperation(CppEmitter &emitter, static LogicalResult printOperation(CppEmitter &emitter,
mlir::ConstantOp constantOp) { mlir::ConstantOp constantOp) {
Operation *operation = constantOp.getOperation(); Operation *operation = constantOp.getOperation();
Attribute value = constantOp.getValueAttr(); Attribute value = constantOp.getValueAttr();
return printConstantOp(emitter, operation, value); return printConstantOp(emitter, operation, value);
} }
static LogicalResult printOperation(CppEmitter &emitter, BranchOp branchOp) { static LogicalResult printOperation(CppEmitter &emitter,
cf::BranchOp branchOp) {
raw_ostream &os = emitter.ostream(); raw_ostream &os = emitter.ostream();
Block &successor = *branchOp.getSuccessor(); Block &successor = *branchOp.getSuccessor();
for (auto pair : for (auto pair :
llvm::zip(branchOp.getOperands(), successor.getArguments())) { llvm::zip(branchOp.getOperands(), successor.getArguments())) {
Value &operand = std::get<0>(pair); Value &operand = std::get<0>(pair);
BlockArgument &argument = std::get<1>(pair); BlockArgument &argument = std::get<1>(pair);
os << emitter.getOrCreateName(argument) << " = " os << emitter.getOrCreateName(argument) << " = "
<< emitter.getOrCreateName(operand) << ";\n"; << emitter.getOrCreateName(operand) << ";\n";
} }
os << "goto "; os << "goto ";
if (!(emitter.hasBlockLabel(successor))) if (!(emitter.hasBlockLabel(successor)))
return branchOp.emitOpError("unable to find label for successor block"); return branchOp.emitOpError("unable to find label for successor block");
os << emitter.getOrCreateName(successor); os << emitter.getOrCreateName(successor);
return success(); return success();
} }
static LogicalResult printOperation(CppEmitter &emitter, static LogicalResult printOperation(CppEmitter &emitter,
CondBranchOp condBranchOp) { cf::CondBranchOp condBranchOp) {
raw_indented_ostream &os = emitter.ostream(); raw_indented_ostream &os = emitter.ostream();
Block &trueSuccessor = *condBranchOp.getTrueDest(); Block &trueSuccessor = *condBranchOp.getTrueDest();
Block &falseSuccessor = *condBranchOp.getFalseDest(); Block &falseSuccessor = *condBranchOp.getFalseDest();
os << "if (" << emitter.getOrCreateName(condBranchOp.getCondition()) os << "if (" << emitter.getOrCreateName(condBranchOp.getCondition())
<< ") {\n"; << ") {\n";
os.indent(); os.indent();
▲ Show 20 Lines • Show All 363 Lines • ▼ Show 20 Linesstatic LogicalResult printOperation(CppEmitter &emitter, FuncOp functionOp) {
for (Block &block : blocks) { for (Block &block : blocks) {
// Only print a label if the block has predecessors. // Only print a label if the block has predecessors.
if (!block.hasNoPredecessors()) { if (!block.hasNoPredecessors()) {
if (failed(emitter.emitLabel(block))) if (failed(emitter.emitLabel(block)))
return failure(); return failure();
} }
for (Operation &op : block.getOperations()) { for (Operation &op : block.getOperations()) {
// When generating code for an scf.if or std.cond_br op no semicolon needs // When generating code for an scf.if or cf.cond_br op no semicolon needs
// to be printed after the closing brace. // to be printed after the closing brace.
// When generating code for an scf.for op, printing a trailing semicolon // When generating code for an scf.for op, printing a trailing semicolon
// is handled within the printOperation function. // is handled within the printOperation function.
bool trailingSemicolon = !isa<scf::IfOp, scf::ForOp, CondBranchOp>(op); bool trailingSemicolon =
!isa<scf::IfOp, scf::ForOp, cf::CondBranchOp>(op);
if (failed(emitter.emitOperation( if (failed(emitter.emitOperation(
op, /*trailingSemicolon=*/trailingSemicolon))) op, /*trailingSemicolon=*/trailingSemicolon)))
return failure(); return failure();
} }
} }
os.unindent() << "}\n"; os.unindent() << "}\n";
return success(); return success();
▲ Show 20 Lines • Show All 249 Lines • ▼ Show 20 Lines LogicalResult status =
// EmitC ops. // EmitC ops.
.Case<emitc::ApplyOp, emitc::CallOp, emitc::ConstantOp, .Case<emitc::ApplyOp, emitc::CallOp, emitc::ConstantOp,
emitc::IncludeOp>( emitc::IncludeOp>(
[&](auto op) { return printOperation(*this, op); }) [&](auto op) { return printOperation(*this, op); })
// SCF ops. // SCF ops.
.Case<scf::ForOp, scf::IfOp, scf::YieldOp>( .Case<scf::ForOp, scf::IfOp, scf::YieldOp>(
[&](auto op) { return printOperation(*this, op); }) [&](auto op) { return printOperation(*this, op); })
// Standard ops. // Standard ops.
.Case<BranchOp, mlir::CallOp, CondBranchOp, mlir::ConstantOp, FuncOp, .Case<cf::BranchOp, mlir::CallOp, cf::CondBranchOp, mlir::ConstantOp,
ModuleOp, ReturnOp>( FuncOp, ModuleOp, ReturnOp>(
[&](auto op) { return printOperation(*this, op); }) [&](auto op) { return printOperation(*this, op); })
// Arithmetic ops. // Arithmetic ops.
.Case<arith::ConstantOp>( .Case<arith::ConstantOp>(
[&](auto op) { return printOperation(*this, op); }) [&](auto op) { return printOperation(*this, op); })
.Default([&](Operation *) { .Default([&](Operation *) {
return op.emitOpError("unable to find printer for op"); return op.emitOpError("unable to find printer for op");
}); });
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
// CHECK-DAG: func.region0#1 <-> func.region0.block2#0: NoAlias // CHECK-DAG: func.region0#1 <-> func.region0.block2#0: NoAlias
// CHECK-DAG: func.region0.block1#0 <-> func.region0.block2#0: MustAlias // CHECK-DAG: func.region0.block1#0 <-> func.region0.block2#0: MustAlias
func @control_flow(%arg: memref<2xf32>, %cond: i1) attributes {test.ptr = "func"} { func @control_flow(%arg: memref<2xf32>, %cond: i1) attributes {test.ptr = "func"} {
%0 = memref.alloca() {test.ptr = "alloca_1"} : memref<8x64xf32> %0 = memref.alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
%1 = memref.alloca() {test.ptr = "alloca_2"} : memref<8x64xf32> %1 = memref.alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
%2 = memref.alloc() {test.ptr = "alloc_1"} : memref<8x64xf32> %2 = memref.alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
cond_br %cond, ^bb1(%0 : memref<8x64xf32>), ^bb2(%0 : memref<8x64xf32>) cf.cond_br %cond, ^bb1(%0 : memref<8x64xf32>), ^bb2(%0 : memref<8x64xf32>)
^bb1(%arg1: memref<8x64xf32>): ^bb1(%arg1: memref<8x64xf32>):
br ^bb2(%arg1 : memref<8x64xf32>) cf.br ^bb2(%arg1 : memref<8x64xf32>)
^bb2(%arg2: memref<8x64xf32>): ^bb2(%arg2: memref<8x64xf32>):
return return
} }
// ----- // -----
// CHECK-LABEL: Testing : "control_flow_merge" // CHECK-LABEL: Testing : "control_flow_merge"
Show All 13 Lines
// CHECK-DAG: func.region0#1 <-> func.region0.block2#0: NoAlias // CHECK-DAG: func.region0#1 <-> func.region0.block2#0: NoAlias
// CHECK-DAG: func.region0.block1#0 <-> func.region0.block2#0: MayAlias // CHECK-DAG: func.region0.block1#0 <-> func.region0.block2#0: MayAlias
func @control_flow_merge(%arg: memref<2xf32>, %cond: i1) attributes {test.ptr = "func"} { func @control_flow_merge(%arg: memref<2xf32>, %cond: i1) attributes {test.ptr = "func"} {
%0 = memref.alloca() {test.ptr = "alloca_1"} : memref<8x64xf32> %0 = memref.alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
%1 = memref.alloca() {test.ptr = "alloca_2"} : memref<8x64xf32> %1 = memref.alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
%2 = memref.alloc() {test.ptr = "alloc_1"} : memref<8x64xf32> %2 = memref.alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
cond_br %cond, ^bb1(%0 : memref<8x64xf32>), ^bb2(%2 : memref<8x64xf32>) cf.cond_br %cond, ^bb1(%0 : memref<8x64xf32>), ^bb2(%2 : memref<8x64xf32>)
^bb1(%arg1: memref<8x64xf32>): ^bb1(%arg1: memref<8x64xf32>):
br ^bb2(%arg1 : memref<8x64xf32>) cf.br ^bb2(%arg1 : memref<8x64xf32>)
^bb2(%arg2: memref<8x64xf32>): ^bb2(%arg2: memref<8x64xf32>):
return return
} }
// ----- // -----
// CHECK-LABEL: Testing : "region_control_flow" // CHECK-LABEL: Testing : "region_control_flow"
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

mlir/test/Analysis/test-dominance.mlir

// RUN: mlir-opt %s -test-print-dominance -split-input-file 2>&1 | FileCheck %s // RUN: mlir-opt %s -test-print-dominance -split-input-file 2>&1 | FileCheck %s
// CHECK-LABEL: Testing : func_condBranch // CHECK-LABEL: Testing : func_condBranch
func @func_condBranch(%cond : i1) { func @func_condBranch(%cond : i1) {
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
br ^exit cf.br ^exit
^bb2: ^bb2:
br ^exit cf.br ^exit
^exit: ^exit:
return return
} }
// CHECK-LABEL: --- DominanceInfo --- // CHECK-LABEL: --- DominanceInfo ---
// CHECK-NEXT: Nearest(0, 0) = 0 // CHECK-NEXT: Nearest(0, 0) = 0
// CHECK-NEXT: Nearest(0, 1) = 0 // CHECK-NEXT: Nearest(0, 1) = 0
// CHECK-NEXT: Nearest(0, 2) = 0 // CHECK-NEXT: Nearest(0, 2) = 0
// CHECK-NEXT: Nearest(0, 3) = 0 // CHECK-NEXT: Nearest(0, 3) = 0
Show All 26 Lines
// CHECK-NEXT: Nearest(3, 1) = 3 // CHECK-NEXT: Nearest(3, 1) = 3
// CHECK-NEXT: Nearest(3, 2) = 3 // CHECK-NEXT: Nearest(3, 2) = 3
// CHECK-NEXT: Nearest(3, 3) = 3 // CHECK-NEXT: Nearest(3, 3) = 3
// ----- // -----
// CHECK-LABEL: Testing : func_loop // CHECK-LABEL: Testing : func_loop
func @func_loop(%arg0 : i32, %arg1 : i32) { func @func_loop(%arg0 : i32, %arg1 : i32) {
br ^loopHeader(%arg0 : i32) cf.br ^loopHeader(%arg0 : i32)
^loopHeader(%counter : i32): ^loopHeader(%counter : i32):
%lessThan = arith.cmpi slt, %counter, %arg1 : i32 %lessThan = arith.cmpi slt, %counter, %arg1 : i32
cond_br %lessThan, ^loopBody, ^exit cf.cond_br %lessThan, ^loopBody, ^exit
^loopBody: ^loopBody:
%const0 = arith.constant 1 : i32 %const0 = arith.constant 1 : i32
%inc = arith.addi %counter, %const0 : i32 %inc = arith.addi %counter, %const0 : i32
br ^loopHeader(%inc : i32) cf.br ^loopHeader(%inc : i32)
^exit: ^exit:
return return
} }
// CHECK-LABEL: --- DominanceInfo --- // CHECK-LABEL: --- DominanceInfo ---
// CHECK: Nearest(1, 0) = 0 // CHECK: Nearest(1, 0) = 0
// CHECK-NEXT: Nearest(1, 1) = 1 // CHECK-NEXT: Nearest(1, 1) = 1
// CHECK-NEXT: Nearest(1, 2) = 1 // CHECK-NEXT: Nearest(1, 2) = 1
// CHECK-NEXT: Nearest(1, 3) = 1 // CHECK-NEXT: Nearest(1, 3) = 1
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
// CHECK-LABEL: Testing : func_loop_nested_region // CHECK-LABEL: Testing : func_loop_nested_region
func @func_loop_nested_region( func @func_loop_nested_region(
%arg0 : i32, %arg0 : i32,
%arg1 : i32, %arg1 : i32,
%arg2 : index, %arg2 : index,
%arg3 : index, %arg3 : index,
%arg4 : index) { %arg4 : index) {
br ^loopHeader(%arg0 : i32) cf.br ^loopHeader(%arg0 : i32)
^loopHeader(%counter : i32): ^loopHeader(%counter : i32):
%lessThan = arith.cmpi slt, %counter, %arg1 : i32 %lessThan = arith.cmpi slt, %counter, %arg1 : i32
cond_br %lessThan, ^loopBody, ^exit cf.cond_br %lessThan, ^loopBody, ^exit
^loopBody: ^loopBody:
%const0 = arith.constant 1 : i32 %const0 = arith.constant 1 : i32
%inc = arith.addi %counter, %const0 : i32 %inc = arith.addi %counter, %const0 : i32
scf.for %arg5 = %arg2 to %arg3 step %arg4 { scf.for %arg5 = %arg2 to %arg3 step %arg4 {
scf.for %arg6 = %arg2 to %arg3 step %arg4 { } scf.for %arg6 = %arg2 to %arg3 step %arg4 { }
} }
br ^loopHeader(%inc : i32) cf.br ^loopHeader(%inc : i32)
^exit: ^exit:
return return
} }
// CHECK-LABEL: --- DominanceInfo --- // CHECK-LABEL: --- DominanceInfo ---
// CHECK: Nearest(2, 0) = 0 // CHECK: Nearest(2, 0) = 0
// CHECK-NEXT: Nearest(2, 1) = 1 // CHECK-NEXT: Nearest(2, 1) = 1
// CHECK-NEXT: Nearest(2, 2) = 2 // CHECK-NEXT: Nearest(2, 2) = 2
// CHECK-NEXT: Nearest(2, 3) = 2 // CHECK-NEXT: Nearest(2, 3) = 2
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

mlir/test/Analysis/test-liveness.mlir

Show All 13 Lines
// CHECK-LABEL: Testing : func_simpleBranch // CHECK-LABEL: Testing : func_simpleBranch
func @func_simpleBranch(%arg0: i32, %arg1 : i32) -> i32 { func @func_simpleBranch(%arg0: i32, %arg1 : i32) -> i32 {
// CHECK: Block: 0 // CHECK: Block: 0
// CHECK-NEXT: LiveIn:{{ *$}} // CHECK-NEXT: LiveIn:{{ *$}}
// CHECK-NEXT: LiveOut: arg0@0 arg1@0 // CHECK-NEXT: LiveOut: arg0@0 arg1@0
// CHECK-NEXT: BeginLiveness // CHECK-NEXT: BeginLiveness
// CHECK-NEXT: EndLiveness // CHECK-NEXT: EndLiveness
br ^exit cf.br ^exit
^exit: ^exit:
// CHECK: Block: 1 // CHECK: Block: 1
// CHECK-NEXT: LiveIn: arg0@0 arg1@0 // CHECK-NEXT: LiveIn: arg0@0 arg1@0
// CHECK-NEXT: LiveOut:{{ *$}} // CHECK-NEXT: LiveOut:{{ *$}}
// CHECK-NEXT: BeginLiveness // CHECK-NEXT: BeginLiveness
// CHECK: val_2 // CHECK: val_2
// CHECK-NEXT: %0 = arith.addi // CHECK-NEXT: %0 = arith.addi
// CHECK-NEXT: return // CHECK-NEXT: return
// CHECK-NEXT: EndLiveness // CHECK-NEXT: EndLiveness
%result = arith.addi %arg0, %arg1 : i32 %result = arith.addi %arg0, %arg1 : i32
return %result : i32 return %result : i32
} }
// ----- // -----
// CHECK-LABEL: Testing : func_condBranch // CHECK-LABEL: Testing : func_condBranch
func @func_condBranch(%cond : i1, %arg1: i32, %arg2 : i32) -> i32 { func @func_condBranch(%cond : i1, %arg1: i32, %arg2 : i32) -> i32 {
// CHECK: Block: 0 // CHECK: Block: 0
// CHECK-NEXT: LiveIn:{{ *$}} // CHECK-NEXT: LiveIn:{{ *$}}
// CHECK-NEXT: LiveOut: arg1@0 arg2@0 // CHECK-NEXT: LiveOut: arg1@0 arg2@0
// CHECK-NEXT: BeginLiveness // CHECK-NEXT: BeginLiveness
// CHECK-NEXT: EndLiveness // CHECK-NEXT: EndLiveness
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
// CHECK: Block: 1 // CHECK: Block: 1
// CHECK-NEXT: LiveIn: arg1@0 arg2@0 // CHECK-NEXT: LiveIn: arg1@0 arg2@0
// CHECK-NEXT: LiveOut: arg1@0 arg2@0 // CHECK-NEXT: LiveOut: arg1@0 arg2@0
br ^exit cf.br ^exit
^bb2: ^bb2:
// CHECK: Block: 2 // CHECK: Block: 2
// CHECK-NEXT: LiveIn: arg1@0 arg2@0 // CHECK-NEXT: LiveIn: arg1@0 arg2@0
// CHECK-NEXT: LiveOut: arg1@0 arg2@0 // CHECK-NEXT: LiveOut: arg1@0 arg2@0
br ^exit cf.br ^exit
^exit: ^exit:
// CHECK: Block: 3 // CHECK: Block: 3
// CHECK-NEXT: LiveIn: arg1@0 arg2@0 // CHECK-NEXT: LiveIn: arg1@0 arg2@0
// CHECK-NEXT: LiveOut:{{ *$}} // CHECK-NEXT: LiveOut:{{ *$}}
// CHECK-NEXT: BeginLiveness // CHECK-NEXT: BeginLiveness
// CHECK: val_3 // CHECK: val_3
// CHECK-NEXT: %0 = arith.addi // CHECK-NEXT: %0 = arith.addi
// CHECK-NEXT: return // CHECK-NEXT: return
// CHECK-NEXT: EndLiveness // CHECK-NEXT: EndLiveness
%result = arith.addi %arg1, %arg2 : i32 %result = arith.addi %arg1, %arg2 : i32
return %result : i32 return %result : i32
} }
// ----- // -----
// CHECK-LABEL: Testing : func_loop // CHECK-LABEL: Testing : func_loop
func @func_loop(%arg0 : i32, %arg1 : i32) -> i32 { func @func_loop(%arg0 : i32, %arg1 : i32) -> i32 {
// CHECK: Block: 0 // CHECK: Block: 0
// CHECK-NEXT: LiveIn:{{ *$}} // CHECK-NEXT: LiveIn:{{ *$}}
// CHECK-NEXT: LiveOut: arg1@0 // CHECK-NEXT: LiveOut: arg1@0
%const0 = arith.constant 0 : i32 %const0 = arith.constant 0 : i32
br ^loopHeader(%const0, %arg0 : i32, i32) cf.br ^loopHeader(%const0, %arg0 : i32, i32)
^loopHeader(%counter : i32, %i : i32): ^loopHeader(%counter : i32, %i : i32):
// CHECK: Block: 1 // CHECK: Block: 1
// CHECK-NEXT: LiveIn: arg1@0 // CHECK-NEXT: LiveIn: arg1@0
// CHECK-NEXT: LiveOut: arg1@0 arg0@1 // CHECK-NEXT: LiveOut: arg1@0 arg0@1
// CHECK-NEXT: BeginLiveness // CHECK-NEXT: BeginLiveness
// CHECK-NEXT: val_5 // CHECK-NEXT: val_5
// CHECK-NEXT: %2 = arith.cmpi // CHECK-NEXT: %2 = arith.cmpi
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK-NEXT: EndLiveness // CHECK-NEXT: EndLiveness
%lessThan = arith.cmpi slt, %counter, %arg1 : i32 %lessThan = arith.cmpi slt, %counter, %arg1 : i32
cond_br %lessThan, ^loopBody(%i : i32), ^exit(%i : i32) cf.cond_br %lessThan, ^loopBody(%i : i32), ^exit(%i : i32)
^loopBody(%val : i32): ^loopBody(%val : i32):
// CHECK: Block: 2 // CHECK: Block: 2
// CHECK-NEXT: LiveIn: arg1@0 arg0@1 // CHECK-NEXT: LiveIn: arg1@0 arg0@1
// CHECK-NEXT: LiveOut: arg1@0 // CHECK-NEXT: LiveOut: arg1@0
// CHECK-NEXT: BeginLiveness // CHECK-NEXT: BeginLiveness
// CHECK-NEXT: val_7 // CHECK-NEXT: val_7
// CHECK-NEXT: %c // CHECK-NEXT: %c
// CHECK-NEXT: %4 = arith.addi // CHECK-NEXT: %4 = arith.addi
// CHECK-NEXT: %5 = arith.addi // CHECK-NEXT: %5 = arith.addi
// CHECK-NEXT: val_8 // CHECK-NEXT: val_8
// CHECK-NEXT: %4 = arith.addi // CHECK-NEXT: %4 = arith.addi
// CHECK-NEXT: %5 = arith.addi // CHECK-NEXT: %5 = arith.addi
// CHECK-NEXT: br // CHECK-NEXT: cf.br
// CHECK: EndLiveness // CHECK: EndLiveness
%const1 = arith.constant 1 : i32 %const1 = arith.constant 1 : i32
%inc = arith.addi %val, %const1 : i32 %inc = arith.addi %val, %const1 : i32
%inc2 = arith.addi %counter, %const1 : i32 %inc2 = arith.addi %counter, %const1 : i32
br ^loopHeader(%inc, %inc2 : i32, i32) cf.br ^loopHeader(%inc, %inc2 : i32, i32)
^exit(%sum : i32): ^exit(%sum : i32):
// CHECK: Block: 3 // CHECK: Block: 3
// CHECK-NEXT: LiveIn: arg1@0 // CHECK-NEXT: LiveIn: arg1@0
// CHECK-NEXT: LiveOut:{{ *$}} // CHECK-NEXT: LiveOut:{{ *$}}
%result = arith.addi %sum, %arg1 : i32 %result = arith.addi %sum, %arg1 : i32
return %result : i32 return %result : i32
} }
Show All 27 Linesfunc @func_ranges(%cond : i1, %arg1 : i32, %arg2 : i32, %arg3 : i32) -> i32 {
// CHECK-NEXT %3 = arith.muli // CHECK-NEXT %3 = arith.muli
// CHECK-NEXT %4 = arith.muli // CHECK-NEXT %4 = arith.muli
// CHECK: val_8 // CHECK: val_8
// CHECK-NEXT: %3 = arith.muli // CHECK-NEXT: %3 = arith.muli
// CHECK-NEXT: %4 = arith.muli // CHECK-NEXT: %4 = arith.muli
// CHECK-NEXT: val_9 // CHECK-NEXT: val_9
// CHECK-NEXT: %4 = arith.muli // CHECK-NEXT: %4 = arith.muli
// CHECK-NEXT: %5 = arith.addi // CHECK-NEXT: %5 = arith.addi
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK-NEXT: %c // CHECK-NEXT: %c
// CHECK-NEXT: %6 = arith.muli // CHECK-NEXT: %6 = arith.muli
// CHECK-NEXT: %7 = arith.muli // CHECK-NEXT: %7 = arith.muli
// CHECK-NEXT: %8 = arith.addi // CHECK-NEXT: %8 = arith.addi
// CHECK-NEXT: val_10 // CHECK-NEXT: val_10
// CHECK-NEXT: %5 = arith.addi // CHECK-NEXT: %5 = arith.addi
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK-NEXT: %7 // CHECK-NEXT: %7
// CHECK: EndLiveness // CHECK: EndLiveness
%0 = arith.addi %arg1, %arg2 : i32 %0 = arith.addi %arg1, %arg2 : i32
%const1 = arith.constant 1 : i32 %const1 = arith.constant 1 : i32
%1 = arith.addi %const1, %arg2 : i32 %1 = arith.addi %const1, %arg2 : i32
%2 = arith.addi %const1, %arg3 : i32 %2 = arith.addi %const1, %arg3 : i32
%3 = arith.muli %0, %1 : i32 %3 = arith.muli %0, %1 : i32
%4 = arith.muli %3, %2 : i32 %4 = arith.muli %3, %2 : i32
%5 = arith.addi %4, %const1 : i32 %5 = arith.addi %4, %const1 : i32
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
// CHECK: Block: 1 // CHECK: Block: 1
// CHECK-NEXT: LiveIn: arg2@0 val_9 // CHECK-NEXT: LiveIn: arg2@0 val_9
// CHECK-NEXT: LiveOut: arg2@0 // CHECK-NEXT: LiveOut: arg2@0
%const4 = arith.constant 4 : i32 %const4 = arith.constant 4 : i32
%6 = arith.muli %4, %const4 : i32 %6 = arith.muli %4, %const4 : i32
br ^exit(%6 : i32) cf.br ^exit(%6 : i32)
^bb2: ^bb2:
// CHECK: Block: 2 // CHECK: Block: 2
// CHECK-NEXT: LiveIn: arg2@0 val_9 val_10 // CHECK-NEXT: LiveIn: arg2@0 val_9 val_10
// CHECK-NEXT: LiveOut: arg2@0 // CHECK-NEXT: LiveOut: arg2@0
%7 = arith.muli %4, %5 : i32 %7 = arith.muli %4, %5 : i32
%8 = arith.addi %4, %arg2 : i32 %8 = arith.addi %4, %arg2 : i32
br ^exit(%8 : i32) cf.br ^exit(%8 : i32)
^exit(%sum : i32): ^exit(%sum : i32):
// CHECK: Block: 3 // CHECK: Block: 3
// CHECK-NEXT: LiveIn: arg2@0 // CHECK-NEXT: LiveIn: arg2@0
// CHECK-NEXT: LiveOut:{{ *$}} // CHECK-NEXT: LiveOut:{{ *$}}
%result = arith.addi %sum, %arg2 : i32 %result = arith.addi %sum, %arg2 : i32
return %result : i32 return %result : i32
} }
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Linesfunc @nested_region3(
// CHECK: Block: 0 // CHECK: Block: 0
// CHECK-NEXT: LiveIn:{{ *$}} // CHECK-NEXT: LiveIn:{{ *$}}
// CHECK-NEXT: LiveOut: arg0@0 arg1@0 arg2@0 arg6@0 val_7 val_8 // CHECK-NEXT: LiveOut: arg0@0 arg1@0 arg2@0 arg6@0 val_7 val_8
// CHECK-NEXT: BeginLiveness // CHECK-NEXT: BeginLiveness
// CHECK-NEXT: val_7 // CHECK-NEXT: val_7
// CHECK-NEXT: %0 = arith.addi // CHECK-NEXT: %0 = arith.addi
// CHECK-NEXT: %1 = arith.addi // CHECK-NEXT: %1 = arith.addi
// CHECK-NEXT: scf.for // CHECK-NEXT: scf.for
// CHECK: // br ^bb1 // CHECK: // cf.br ^bb1
// CHECK-NEXT: %2 = arith.addi // CHECK-NEXT: %2 = arith.addi
// CHECK-NEXT: scf.for // CHECK-NEXT: scf.for
// CHECK: // %2 = arith.addi // CHECK: // %2 = arith.addi
// CHECK: EndLiveness // CHECK: EndLiveness
%arg0 : index, %arg1 : index, %arg2 : index, %arg0 : index, %arg1 : index, %arg2 : index,
%arg3 : i32, %arg4 : i32, %arg5 : i32, %arg3 : i32, %arg4 : i32, %arg5 : i32,
%buffer : memref<i32>) -> i32 { %buffer : memref<i32>) -> i32 {
%0 = arith.addi %arg3, %arg4 : i32 %0 = arith.addi %arg3, %arg4 : i32
%1 = arith.addi %arg4, %arg5 : i32 %1 = arith.addi %arg4, %arg5 : i32
scf.for %arg6 = %arg0 to %arg1 step %arg2 { scf.for %arg6 = %arg0 to %arg1 step %arg2 {
// CHECK: Block: 1 // CHECK: Block: 1
// CHECK-NEXT: LiveIn: arg5@0 arg6@0 val_7 // CHECK-NEXT: LiveIn: arg5@0 arg6@0 val_7
// CHECK-NEXT: LiveOut:{{ *$}} // CHECK-NEXT: LiveOut:{{ *$}}
%2 = arith.addi %0, %arg5 : i32 %2 = arith.addi %0, %arg5 : i32
memref.store %2, %buffer[] : memref<i32> memref.store %2, %buffer[] : memref<i32>
} }
br ^exit cf.br ^exit
^exit: ^exit:
// CHECK: Block: 2 // CHECK: Block: 2
// CHECK-NEXT: LiveIn: arg0@0 arg1@0 arg2@0 arg6@0 val_7 val_8 // CHECK-NEXT: LiveIn: arg0@0 arg1@0 arg2@0 arg6@0 val_7 val_8
// CHECK-NEXT: LiveOut:{{ *$}} // CHECK-NEXT: LiveOut:{{ *$}}
scf.for %arg7 = %arg0 to %arg1 step %arg2 { scf.for %arg7 = %arg0 to %arg1 step %arg2 {
// CHECK: Block: 3 // CHECK: Block: 3
// CHECK-NEXT: LiveIn: arg6@0 val_7 val_8 // CHECK-NEXT: LiveIn: arg6@0 val_7 val_8
// CHECK-NEXT: LiveOut:{{ *$}} // CHECK-NEXT: LiveOut:{{ *$}}
%2 = arith.addi %0, %1 : i32 %2 = arith.addi %0, %1 : i32
memref.store %2, %buffer[] : memref<i32> memref.store %2, %buffer[] : memref<i32>
} }
return %1 : i32 return %1 : i32
} }

mlir/test/CAPI/ir.c

Show First 20 Lines • Show All 1,525 Lines • ▼ Show 20 Linesint registerOnlyStd() {
MlirStringRef alsoStdNs = mlirDialectHandleGetNamespace(stdHandle); MlirStringRef alsoStdNs = mlirDialectHandleGetNamespace(stdHandle);
if (stdNs.length != alsoStdNs.length || if (stdNs.length != alsoStdNs.length ||
strncmp(stdNs.data, alsoStdNs.data, stdNs.length)) strncmp(stdNs.data, alsoStdNs.data, stdNs.length))
return 5; return 5;
fprintf(stderr, "@registration\n"); fprintf(stderr, "@registration\n");
// CHECK-LABEL: @registration // CHECK-LABEL: @registration
// CHECK: std.cond_br is_registered: 1 // CHECK: cf.cond_br is_registered: 1
fprintf(stderr, "std.cond_br is_registered: %d\n", fprintf(stderr, "cf.cond_br is_registered: %d\n",
mlirContextIsRegisteredOperation( mlirContextIsRegisteredOperation(
ctx, mlirStringRefCreateFromCString("std.cond_br"))); ctx, mlirStringRefCreateFromCString("cf.cond_br")));
// CHECK: std.not_existing_op is_registered: 0 // CHECK: std.not_existing_op is_registered: 0
fprintf(stderr, "std.not_existing_op is_registered: %d\n", fprintf(stderr, "std.not_existing_op is_registered: %d\n",
mlirContextIsRegisteredOperation( mlirContextIsRegisteredOperation(
ctx, mlirStringRefCreateFromCString("std.not_existing_op"))); ctx, mlirStringRefCreateFromCString("std.not_existing_op")));
// CHECK: not_existing_dialect.not_existing_op is_registered: 0 // CHECK: not_existing_dialect.not_existing_op is_registered: 0
fprintf(stderr, "not_existing_dialect.not_existing_op is_registered: %d\n", fprintf(stderr, "not_existing_dialect.not_existing_op is_registered: %d\n",
▲ Show 20 Lines • Show All 483 Lines • Show Last 20 Lines

mlir/test/Conversion/AsyncToLLVM/convert-to-llvm.mlir

Show All 21 Lines %token = async.execute {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
memref.store %arg0, %arg1[%c0] : memref<1xf32> memref.store %arg0, %arg1[%c0] : memref<1xf32>
async.yield async.yield
} }
// CHECK: call @mlirAsyncRuntimeAwaitToken(%[[TOKEN]]) // CHECK: call @mlirAsyncRuntimeAwaitToken(%[[TOKEN]])
// CHECK: %[[IS_ERROR:.*]] = call @mlirAsyncRuntimeIsTokenError(%[[TOKEN]]) // CHECK: %[[IS_ERROR:.*]] = call @mlirAsyncRuntimeIsTokenError(%[[TOKEN]])
// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[TRUE:.*]] = arith.constant true
// CHECK: %[[NOT_ERROR:.*]] = arith.xori %[[IS_ERROR]], %[[TRUE]] : i1 // CHECK: %[[NOT_ERROR:.*]] = arith.xori %[[IS_ERROR]], %[[TRUE]] : i1
// CHECK: assert %[[NOT_ERROR]] // CHECK: cf.assert %[[NOT_ERROR]]
// CHECK-NEXT: return // CHECK-NEXT: return
async.await %token : !async.token async.await %token : !async.token
return return
} }
// Function outlined from the async.execute operation. // Function outlined from the async.execute operation.
// CHECK-LABEL: func private @async_execute_fn(%arg0: f32, %arg1: memref<1xf32>) // CHECK-LABEL: func private @async_execute_fn(%arg0: f32, %arg1: memref<1xf32>)
// CHECK-SAME: -> !llvm.ptr<i8> // CHECK-SAME: -> !llvm.ptr<i8>
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines %token0 = async.execute {
memref.store %arg1, %arg2[%c0] : memref<1xf32> memref.store %arg1, %arg2[%c0] : memref<1xf32>
async.yield async.yield
} }
// CHECK: call @mlirAsyncRuntimeAwaitToken(%[[TOKEN]]) // CHECK: call @mlirAsyncRuntimeAwaitToken(%[[TOKEN]])
// CHECK: %[[IS_ERROR:.*]] = call @mlirAsyncRuntimeIsTokenError(%[[TOKEN]]) // CHECK: %[[IS_ERROR:.*]] = call @mlirAsyncRuntimeIsTokenError(%[[TOKEN]])
// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[TRUE:.*]] = arith.constant true
// CHECK: %[[NOT_ERROR:.*]] = arith.xori %[[IS_ERROR]], %[[TRUE]] : i1 // CHECK: %[[NOT_ERROR:.*]] = arith.xori %[[IS_ERROR]], %[[TRUE]] : i1
// CHECK: assert %[[NOT_ERROR]] // CHECK: cf.assert %[[NOT_ERROR]]
async.await %token0 : !async.token async.await %token0 : !async.token
return return
} }
// Function outlined from the inner async.execute operation. // Function outlined from the inner async.execute operation.
// CHECK-LABEL: func private @async_execute_fn(%arg0: f32, %arg1: memref<1xf32>) // CHECK-LABEL: func private @async_execute_fn(%arg0: f32, %arg1: memref<1xf32>)
// CHECK-SAME: -> !llvm.ptr<i8> // CHECK-SAME: -> !llvm.ptr<i8>
// CHECK: %[[RET_0:.*]] = call @mlirAsyncRuntimeCreateToken() // CHECK: %[[RET_0:.*]] = call @mlirAsyncRuntimeCreateToken()
▲ Show 20 Lines • Show All 204 Lines • Show Last 20 Lines

mlir/test/Conversion/ControlFlowToSPIRV/cf-ops-to-spirv.mlir

  • This file was added.
// RUN: mlir-opt -split-input-file -convert-std-to-spirv -verify-diagnostics %s | FileCheck %s
//===----------------------------------------------------------------------===//
// cf.br, cf.cond_br
//===----------------------------------------------------------------------===//
module attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.0, [], []>, {}>
} {
// CHECK-LABEL: func @simple_loop
func @simple_loop(index, index, index) {
^bb0(%begin : index, %end : index, %step : index):
// CHECK-NEXT: spv.Branch ^bb1
cf.br ^bb1
// CHECK-NEXT: ^bb1: // pred: ^bb0
// CHECK-NEXT: spv.Branch ^bb2({{.*}} : i32)
^bb1: // pred: ^bb0
cf.br ^bb2(%begin : index)
// CHECK: ^bb2({{.*}}: i32): // 2 preds: ^bb1, ^bb3
// CHECK-NEXT: {{.*}} = spv.SLessThan {{.*}}, {{.*}} : i32
// CHECK-NEXT: spv.BranchConditional {{.*}}, ^bb3, ^bb4
^bb2(%0: index): // 2 preds: ^bb1, ^bb3
%1 = arith.cmpi slt, %0, %end : index
cf.cond_br %1, ^bb3, ^bb4
// CHECK: ^bb3: // pred: ^bb2
// CHECK-NEXT: {{.*}} = spv.IAdd {{.*}}, {{.*}} : i32
// CHECK-NEXT: spv.Branch ^bb2({{.*}} : i32)
^bb3: // pred: ^bb2
%2 = arith.addi %0, %step : index
cf.br ^bb2(%2 : index)
// CHECK: ^bb4: // pred: ^bb2
^bb4: // pred: ^bb2
return
}
}

mlir/test/Conversion/GPUToNVVM/wmma-ops-to-nvvm.mlir

Show First 20 Lines • Show All 162 Lines • ▼ Show 20 Lines
// CHECK: %[[E3:.+]] = llvm.extractvalue %[[ACC]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[E3:.+]] = llvm.extractvalue %[[ACC]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: nvvm.wmma.store %{{.*}}, %{{.*}}, %[[E0]], %[[E1]], %[[E2]], %[[E3]] {eltype = #nvvm.mma_type<f16>, k = 16 : i32, layout = #nvvm.mma_layout<row>, m = 16 : i32, n = 16 : i32} : !llvm.ptr<f16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16> // CHECK: nvvm.wmma.store %{{.*}}, %{{.*}}, %[[E0]], %[[E1]], %[[E2]], %[[E3]] {eltype = #nvvm.mma_type<f16>, k = 16 : i32, layout = #nvvm.mma_layout<row>, m = 16 : i32, n = 16 : i32} : !llvm.ptr<f16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>
builtin.func @gpu_wmma_mma_loop_op(%arg0: memref<128x128xf16>, %arg1: memref<128x128xf16>, %arg2: memref<128x128xf16>) { builtin.func @gpu_wmma_mma_loop_op(%arg0: memref<128x128xf16>, %arg1: memref<128x128xf16>, %arg2: memref<128x128xf16>) {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c128 = arith.constant 128 : index %c128 = arith.constant 128 : index
%c32 = arith.constant 32 : index %c32 = arith.constant 32 : index
%0 = gpu.subgroup_mma_load_matrix %arg2[%c0, %c0] {leadDimension = 128 : index} : memref<128x128xf16> -> !gpu.mma_matrix<16x16xf16, "COp"> %0 = gpu.subgroup_mma_load_matrix %arg2[%c0, %c0] {leadDimension = 128 : index} : memref<128x128xf16> -> !gpu.mma_matrix<16x16xf16, "COp">
br ^bb1(%c0, %0 : index, !gpu.mma_matrix<16x16xf16, "COp">) cf.br ^bb1(%c0, %0 : index, !gpu.mma_matrix<16x16xf16, "COp">)
^bb1(%1: index, %2: !gpu.mma_matrix<16x16xf16, "COp">): // 2 preds: ^bb0, ^bb2 ^bb1(%1: index, %2: !gpu.mma_matrix<16x16xf16, "COp">): // 2 preds: ^bb0, ^bb2
%3 = arith.cmpi slt, %1, %c128 : index %3 = arith.cmpi slt, %1, %c128 : index
cond_br %3, ^bb2, ^bb3 cf.cond_br %3, ^bb2, ^bb3
^bb2: // pred: ^bb1 ^bb2: // pred: ^bb1
%4 = gpu.subgroup_mma_load_matrix %arg0[%c0, %1] {leadDimension = 128 : index} : memref<128x128xf16> -> !gpu.mma_matrix<16x16xf16, "AOp"> %4 = gpu.subgroup_mma_load_matrix %arg0[%c0, %1] {leadDimension = 128 : index} : memref<128x128xf16> -> !gpu.mma_matrix<16x16xf16, "AOp">
%5 = gpu.subgroup_mma_load_matrix %arg1[%1, %c0] {leadDimension = 128 : index} : memref<128x128xf16> -> !gpu.mma_matrix<16x16xf16, "BOp"> %5 = gpu.subgroup_mma_load_matrix %arg1[%1, %c0] {leadDimension = 128 : index} : memref<128x128xf16> -> !gpu.mma_matrix<16x16xf16, "BOp">
%6 = gpu.subgroup_mma_compute %4, %5, %2 : !gpu.mma_matrix<16x16xf16, "AOp">, !gpu.mma_matrix<16x16xf16, "BOp"> -> !gpu.mma_matrix<16x16xf16, "COp"> %6 = gpu.subgroup_mma_compute %4, %5, %2 : !gpu.mma_matrix<16x16xf16, "AOp">, !gpu.mma_matrix<16x16xf16, "BOp"> -> !gpu.mma_matrix<16x16xf16, "COp">
%7 = arith.addi %1, %c32 : index %7 = arith.addi %1, %c32 : index
br ^bb1(%7, %6 : index, !gpu.mma_matrix<16x16xf16, "COp">) cf.br ^bb1(%7, %6 : index, !gpu.mma_matrix<16x16xf16, "COp">)
^bb3: // pred: ^bb1 ^bb3: // pred: ^bb1
gpu.subgroup_mma_store_matrix %2, %arg2[%c0, %c0] {leadDimension = 128 : index} : !gpu.mma_matrix<16x16xf16, "COp">, memref<128x128xf16> gpu.subgroup_mma_store_matrix %2, %arg2[%c0, %c0] {leadDimension = 128 : index} : !gpu.mma_matrix<16x16xf16, "COp">, memref<128x128xf16>
return return
} }
} }
// ----- // -----
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

mlir/test/Conversion/OpenMPToLLVM/convert-to-llvmir.mlir

Show All 16 Lines
// CHECK-LABEL: llvm.func @branch_loop // CHECK-LABEL: llvm.func @branch_loop
func @branch_loop() { func @branch_loop() {
%start = arith.constant 0 : index %start = arith.constant 0 : index
%end = arith.constant 0 : index %end = arith.constant 0 : index
// CHECK: omp.parallel // CHECK: omp.parallel
omp.parallel { omp.parallel {
// CHECK-NEXT: llvm.br ^[[BB1:.*]](%{{[0-9]+}}, %{{[0-9]+}} : i64, i64 // CHECK-NEXT: llvm.br ^[[BB1:.*]](%{{[0-9]+}}, %{{[0-9]+}} : i64, i64
br ^bb1(%start, %end : index, index) cf.br ^bb1(%start, %end : index, index)
// CHECK-NEXT: ^[[BB1]](%[[ARG1:[0-9]+]]: i64, %[[ARG2:[0-9]+]]: i64):{{.*}} // CHECK-NEXT: ^[[BB1]](%[[ARG1:[0-9]+]]: i64, %[[ARG2:[0-9]+]]: i64):{{.*}}
^bb1(%0: index, %1: index): ^bb1(%0: index, %1: index):
// CHECK-NEXT: %[[CMP:[0-9]+]] = llvm.icmp "slt" %[[ARG1]], %[[ARG2]] : i64 // CHECK-NEXT: %[[CMP:[0-9]+]] = llvm.icmp "slt" %[[ARG1]], %[[ARG2]] : i64
%2 = arith.cmpi slt, %0, %1 : index %2 = arith.cmpi slt, %0, %1 : index
// CHECK-NEXT: llvm.cond_br %[[CMP]], ^[[BB2:.*]](%{{[0-9]+}}, %{{[0-9]+}} : i64, i64), ^[[BB3:.*]] // CHECK-NEXT: llvm.cond_br %[[CMP]], ^[[BB2:.*]](%{{[0-9]+}}, %{{[0-9]+}} : i64, i64), ^[[BB3:.*]]
cond_br %2, ^bb2(%end, %end : index, index), ^bb3 cf.cond_br %2, ^bb2(%end, %end : index, index), ^bb3
// CHECK-NEXT: ^[[BB2]](%[[ARG3:[0-9]+]]: i64, %[[ARG4:[0-9]+]]: i64): // CHECK-NEXT: ^[[BB2]](%[[ARG3:[0-9]+]]: i64, %[[ARG4:[0-9]+]]: i64):
^bb2(%3: index, %4: index): ^bb2(%3: index, %4: index):
// CHECK-NEXT: llvm.br ^[[BB1]](%[[ARG3]], %[[ARG4]] : i64, i64) // CHECK-NEXT: llvm.br ^[[BB1]](%[[ARG3]], %[[ARG4]] : i64, i64)
br ^bb1(%3, %4 : index, index) cf.br ^bb1(%3, %4 : index, index)
// CHECK-NEXT: ^[[BB3]]: // CHECK-NEXT: ^[[BB3]]:
^bb3: ^bb3:
omp.flush omp.flush
omp.barrier omp.barrier
omp.taskwait omp.taskwait
omp.taskyield omp.taskyield
omp.terminator omp.terminator
} }
Show All 21 Lines

mlir/test/Conversion/SCFToControlFlow/convert-to-cfg.mlir

  • This file was moved from mlir/test/Conversion/SCFToStandard/convert-to-cfg.mlir.
// RUN: mlir-opt -allow-unregistered-dialect -convert-scf-to-std %s | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect -convert-scf-to-cf %s | FileCheck %s
// CHECK-LABEL: func @simple_std_for_loop(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index) { // CHECK-LABEL: func @simple_std_for_loop(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
// CHECK-NEXT: br ^bb1(%{{.*}} : index) // CHECK-NEXT: cf.br ^bb1(%{{.*}} : index)
// CHECK-NEXT: ^bb1(%{{.*}}: index): // 2 preds: ^bb0, ^bb2 // CHECK-NEXT: ^bb1(%{{.*}}: index): // 2 preds: ^bb0, ^bb2
// CHECK-NEXT: %{{.*}} = arith.cmpi slt, %{{.*}}, %{{.*}} : index // CHECK-NEXT: %{{.*}} = arith.cmpi slt, %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb2, ^bb3 // CHECK-NEXT: cf.cond_br %{{.*}}, ^bb2, ^bb3
// CHECK-NEXT: ^bb2: // pred: ^bb1 // CHECK-NEXT: ^bb2: // pred: ^bb1
// CHECK-NEXT: %{{.*}} = arith.constant 1 : index // CHECK-NEXT: %{{.*}} = arith.constant 1 : index
// CHECK-NEXT: %[[iv:.*]] = arith.addi %{{.*}}, %{{.*}} : index // CHECK-NEXT: %[[iv:.*]] = arith.addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb1(%[[iv]] : index) // CHECK-NEXT: cf.br ^bb1(%[[iv]] : index)
// CHECK-NEXT: ^bb3: // pred: ^bb1 // CHECK-NEXT: ^bb3: // pred: ^bb1
// CHECK-NEXT: return // CHECK-NEXT: return
func @simple_std_for_loop(%arg0 : index, %arg1 : index, %arg2 : index) { func @simple_std_for_loop(%arg0 : index, %arg1 : index, %arg2 : index) {
scf.for %i0 = %arg0 to %arg1 step %arg2 { scf.for %i0 = %arg0 to %arg1 step %arg2 {
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
} }
return return
} }
// CHECK-LABEL: func @simple_std_2_for_loops(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index) { // CHECK-LABEL: func @simple_std_2_for_loops(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
// CHECK-NEXT: br ^bb1(%{{.*}} : index) // CHECK-NEXT: cf.br ^bb1(%{{.*}} : index)
// CHECK-NEXT: ^bb1(%[[ub0:.*]]: index): // 2 preds: ^bb0, ^bb5 // CHECK-NEXT: ^bb1(%[[ub0:.*]]: index): // 2 preds: ^bb0, ^bb5
// CHECK-NEXT: %[[cond0:.*]] = arith.cmpi slt, %[[ub0]], %{{.*}} : index // CHECK-NEXT: %[[cond0:.*]] = arith.cmpi slt, %[[ub0]], %{{.*}} : index
// CHECK-NEXT: cond_br %[[cond0]], ^bb2, ^bb6 // CHECK-NEXT: cf.cond_br %[[cond0]], ^bb2, ^bb6
// CHECK-NEXT: ^bb2: // pred: ^bb1 // CHECK-NEXT: ^bb2: // pred: ^bb1
// CHECK-NEXT: %{{.*}} = arith.constant 1 : index // CHECK-NEXT: %{{.*}} = arith.constant 1 : index
// CHECK-NEXT: br ^bb3(%{{.*}} : index) // CHECK-NEXT: cf.br ^bb3(%{{.*}} : index)
// CHECK-NEXT: ^bb3(%[[ub1:.*]]: index): // 2 preds: ^bb2, ^bb4 // CHECK-NEXT: ^bb3(%[[ub1:.*]]: index): // 2 preds: ^bb2, ^bb4
// CHECK-NEXT: %[[cond1:.*]] = arith.cmpi slt, %{{.*}}, %{{.*}} : index // CHECK-NEXT: %[[cond1:.*]] = arith.cmpi slt, %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %[[cond1]], ^bb4, ^bb5 // CHECK-NEXT: cf.cond_br %[[cond1]], ^bb4, ^bb5
// CHECK-NEXT: ^bb4: // pred: ^bb3 // CHECK-NEXT: ^bb4: // pred: ^bb3
// CHECK-NEXT: %{{.*}} = arith.constant 1 : index // CHECK-NEXT: %{{.*}} = arith.constant 1 : index
// CHECK-NEXT: %[[iv1:.*]] = arith.addi %{{.*}}, %{{.*}} : index // CHECK-NEXT: %[[iv1:.*]] = arith.addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb3(%[[iv1]] : index) // CHECK-NEXT: cf.br ^bb3(%[[iv1]] : index)
// CHECK-NEXT: ^bb5: // pred: ^bb3 // CHECK-NEXT: ^bb5: // pred: ^bb3
// CHECK-NEXT: %[[iv0:.*]] = arith.addi %{{.*}}, %{{.*}} : index // CHECK-NEXT: %[[iv0:.*]] = arith.addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb1(%[[iv0]] : index) // CHECK-NEXT: cf.br ^bb1(%[[iv0]] : index)
// CHECK-NEXT: ^bb6: // pred: ^bb1 // CHECK-NEXT: ^bb6: // pred: ^bb1
// CHECK-NEXT: return // CHECK-NEXT: return
func @simple_std_2_for_loops(%arg0 : index, %arg1 : index, %arg2 : index) { func @simple_std_2_for_loops(%arg0 : index, %arg1 : index, %arg2 : index) {
scf.for %i0 = %arg0 to %arg1 step %arg2 { scf.for %i0 = %arg0 to %arg1 step %arg2 {
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
scf.for %i1 = %arg0 to %arg1 step %arg2 { scf.for %i1 = %arg0 to %arg1 step %arg2 {
%c1_0 = arith.constant 1 : index %c1_0 = arith.constant 1 : index
} }
} }
return return
} }
// CHECK-LABEL: func @simple_std_if(%{{.*}}: i1) { // CHECK-LABEL: func @simple_std_if(%{{.*}}: i1) {
// CHECK-NEXT: cond_br %{{.*}}, ^bb1, ^bb2 // CHECK-NEXT: cf.cond_br %{{.*}}, ^bb1, ^bb2
// CHECK-NEXT: ^bb1: // pred: ^bb0 // CHECK-NEXT: ^bb1: // pred: ^bb0
// CHECK-NEXT: %{{.*}} = arith.constant 1 : index // CHECK-NEXT: %{{.*}} = arith.constant 1 : index
// CHECK-NEXT: br ^bb2 // CHECK-NEXT: cf.br ^bb2
// CHECK-NEXT: ^bb2: // 2 preds: ^bb0, ^bb1 // CHECK-NEXT: ^bb2: // 2 preds: ^bb0, ^bb1
// CHECK-NEXT: return // CHECK-NEXT: return
func @simple_std_if(%arg0: i1) { func @simple_std_if(%arg0: i1) {
scf.if %arg0 { scf.if %arg0 {
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
} }
return return
} }
// CHECK-LABEL: func @simple_std_if_else(%{{.*}}: i1) { // CHECK-LABEL: func @simple_std_if_else(%{{.*}}: i1) {
// CHECK-NEXT: cond_br %{{.*}}, ^bb1, ^bb2 // CHECK-NEXT: cf.cond_br %{{.*}}, ^bb1, ^bb2
// CHECK-NEXT: ^bb1: // pred: ^bb0 // CHECK-NEXT: ^bb1: // pred: ^bb0
// CHECK-NEXT: %{{.*}} = arith.constant 1 : index // CHECK-NEXT: %{{.*}} = arith.constant 1 : index
// CHECK-NEXT: br ^bb3 // CHECK-NEXT: cf.br ^bb3
// CHECK-NEXT: ^bb2: // pred: ^bb0 // CHECK-NEXT: ^bb2: // pred: ^bb0
// CHECK-NEXT: %{{.*}} = arith.constant 1 : index // CHECK-NEXT: %{{.*}} = arith.constant 1 : index
// CHECK-NEXT: br ^bb3 // CHECK-NEXT: cf.br ^bb3
// CHECK-NEXT: ^bb3: // 2 preds: ^bb1, ^bb2 // CHECK-NEXT: ^bb3: // 2 preds: ^bb1, ^bb2
// CHECK-NEXT: return // CHECK-NEXT: return
func @simple_std_if_else(%arg0: i1) { func @simple_std_if_else(%arg0: i1) {
scf.if %arg0 { scf.if %arg0 {
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
} else { } else {
%c1_0 = arith.constant 1 : index %c1_0 = arith.constant 1 : index
} }
return return
} }
// CHECK-LABEL: func @simple_std_2_ifs(%{{.*}}: i1) { // CHECK-LABEL: func @simple_std_2_ifs(%{{.*}}: i1) {
// CHECK-NEXT: cond_br %{{.*}}, ^bb1, ^bb5 // CHECK-NEXT: cf.cond_br %{{.*}}, ^bb1, ^bb5
// CHECK-NEXT: ^bb1: // pred: ^bb0 // CHECK-NEXT: ^bb1: // pred: ^bb0
// CHECK-NEXT: %{{.*}} = arith.constant 1 : index // CHECK-NEXT: %{{.*}} = arith.constant 1 : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb2, ^bb3 // CHECK-NEXT: cf.cond_br %{{.*}}, ^bb2, ^bb3
// CHECK-NEXT: ^bb2: // pred: ^bb1 // CHECK-NEXT: ^bb2: // pred: ^bb1
// CHECK-NEXT: %{{.*}} = arith.constant 1 : index // CHECK-NEXT: %{{.*}} = arith.constant 1 : index
// CHECK-NEXT: br ^bb4 // CHECK-NEXT: cf.br ^bb4
// CHECK-NEXT: ^bb3: // pred: ^bb1 // CHECK-NEXT: ^bb3: // pred: ^bb1
// CHECK-NEXT: %{{.*}} = arith.constant 1 : index // CHECK-NEXT: %{{.*}} = arith.constant 1 : index
// CHECK-NEXT: br ^bb4 // CHECK-NEXT: cf.br ^bb4
// CHECK-NEXT: ^bb4: // 2 preds: ^bb2, ^bb3 // CHECK-NEXT: ^bb4: // 2 preds: ^bb2, ^bb3
// CHECK-NEXT: br ^bb5 // CHECK-NEXT: cf.br ^bb5
// CHECK-NEXT: ^bb5: // 2 preds: ^bb0, ^bb4 // CHECK-NEXT: ^bb5: // 2 preds: ^bb0, ^bb4
// CHECK-NEXT: return // CHECK-NEXT: return
func @simple_std_2_ifs(%arg0: i1) { func @simple_std_2_ifs(%arg0: i1) {
scf.if %arg0 { scf.if %arg0 {
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
scf.if %arg0 { scf.if %arg0 {
%c1_0 = arith.constant 1 : index %c1_0 = arith.constant 1 : index
} else { } else {
%c1_1 = arith.constant 1 : index %c1_1 = arith.constant 1 : index
} }
} }
return return
} }
// CHECK-LABEL: func @simple_std_for_loop_with_2_ifs(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: i1) { // CHECK-LABEL: func @simple_std_for_loop_with_2_ifs(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: i1) {
// CHECK-NEXT: br ^bb1(%{{.*}} : index) // CHECK-NEXT: cf.br ^bb1(%{{.*}} : index)
// CHECK-NEXT: ^bb1(%{{.*}}: index): // 2 preds: ^bb0, ^bb7 // CHECK-NEXT: ^bb1(%{{.*}}: index): // 2 preds: ^bb0, ^bb7
// CHECK-NEXT: %{{.*}} = arith.cmpi slt, %{{.*}}, %{{.*}} : index // CHECK-NEXT: %{{.*}} = arith.cmpi slt, %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb2, ^bb8 // CHECK-NEXT: cf.cond_br %{{.*}}, ^bb2, ^bb8
// CHECK-NEXT: ^bb2: // pred: ^bb1 // CHECK-NEXT: ^bb2: // pred: ^bb1
// CHECK-NEXT: %{{.*}} = arith.constant 1 : index // CHECK-NEXT: %{{.*}} = arith.constant 1 : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb3, ^bb7 // CHECK-NEXT: cf.cond_br %{{.*}}, ^bb3, ^bb7
// CHECK-NEXT: ^bb3: // pred: ^bb2 // CHECK-NEXT: ^bb3: // pred: ^bb2
// CHECK-NEXT: %{{.*}} = arith.constant 1 : index // CHECK-NEXT: %{{.*}} = arith.constant 1 : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb4, ^bb5 // CHECK-NEXT: cf.cond_br %{{.*}}, ^bb4, ^bb5
// CHECK-NEXT: ^bb4: // pred: ^bb3 // CHECK-NEXT: ^bb4: // pred: ^bb3
// CHECK-NEXT: %{{.*}} = arith.constant 1 : index // CHECK-NEXT: %{{.*}} = arith.constant 1 : index
// CHECK-NEXT: br ^bb6 // CHECK-NEXT: cf.br ^bb6
// CHECK-NEXT: ^bb5: // pred: ^bb3 // CHECK-NEXT: ^bb5: // pred: ^bb3
// CHECK-NEXT: %{{.*}} = arith.constant 1 : index // CHECK-NEXT: %{{.*}} = arith.constant 1 : index
// CHECK-NEXT: br ^bb6 // CHECK-NEXT: cf.br ^bb6
// CHECK-NEXT: ^bb6: // 2 preds: ^bb4, ^bb5 // CHECK-NEXT: ^bb6: // 2 preds: ^bb4, ^bb5
// CHECK-NEXT: br ^bb7 // CHECK-NEXT: cf.br ^bb7
// CHECK-NEXT: ^bb7: // 2 preds: ^bb2, ^bb6 // CHECK-NEXT: ^bb7: // 2 preds: ^bb2, ^bb6
// CHECK-NEXT: %[[iv0:.*]] = arith.addi %{{.*}}, %{{.*}} : index // CHECK-NEXT: %[[iv0:.*]] = arith.addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb1(%[[iv0]] : index) // CHECK-NEXT: cf.br ^bb1(%[[iv0]] : index)
// CHECK-NEXT: ^bb8: // pred: ^bb1 // CHECK-NEXT: ^bb8: // pred: ^bb1
// CHECK-NEXT: return // CHECK-NEXT: return
// CHECK-NEXT: } // CHECK-NEXT: }
func @simple_std_for_loop_with_2_ifs(%arg0 : index, %arg1 : index, %arg2 : index, %arg3 : i1) { func @simple_std_for_loop_with_2_ifs(%arg0 : index, %arg1 : index, %arg2 : index, %arg3 : i1) {
scf.for %i0 = %arg0 to %arg1 step %arg2 { scf.for %i0 = %arg0 to %arg1 step %arg2 {
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
scf.if %arg3 { scf.if %arg3 {
%c1_0 = arith.constant 1 : index %c1_0 = arith.constant 1 : index
scf.if %arg3 { scf.if %arg3 {
%c1_1 = arith.constant 1 : index %c1_1 = arith.constant 1 : index
} else { } else {
%c1_2 = arith.constant 1 : index %c1_2 = arith.constant 1 : index
} }
} }
} }
return return
} }
// CHECK-LABEL: func @simple_if_yield // CHECK-LABEL: func @simple_if_yield
func @simple_if_yield(%arg0: i1) -> (i1, i1) { func @simple_if_yield(%arg0: i1) -> (i1, i1) {
// CHECK: cond_br %{{.*}}, ^[[then:.*]], ^[[else:.*]] // CHECK: cf.cond_br %{{.*}}, ^[[then:.*]], ^[[else:.*]]
%0:2 = scf.if %arg0 -> (i1, i1) { %0:2 = scf.if %arg0 -> (i1, i1) {
// CHECK: ^[[then]]: // CHECK: ^[[then]]:
// CHECK: %[[v0:.*]] = arith.constant false // CHECK: %[[v0:.*]] = arith.constant false
// CHECK: %[[v1:.*]] = arith.constant true // CHECK: %[[v1:.*]] = arith.constant true
// CHECK: br ^[[dom:.*]](%[[v0]], %[[v1]] : i1, i1) // CHECK: cf.br ^[[dom:.*]](%[[v0]], %[[v1]] : i1, i1)
%c0 = arith.constant false %c0 = arith.constant false
%c1 = arith.constant true %c1 = arith.constant true
scf.yield %c0, %c1 : i1, i1 scf.yield %c0, %c1 : i1, i1
} else { } else {
// CHECK: ^[[else]]: // CHECK: ^[[else]]:
// CHECK: %[[v2:.*]] = arith.constant false // CHECK: %[[v2:.*]] = arith.constant false
// CHECK: %[[v3:.*]] = arith.constant true // CHECK: %[[v3:.*]] = arith.constant true
// CHECK: br ^[[dom]](%[[v3]], %[[v2]] : i1, i1) // CHECK: cf.br ^[[dom]](%[[v3]], %[[v2]] : i1, i1)
%c0 = arith.constant false %c0 = arith.constant false
%c1 = arith.constant true %c1 = arith.constant true
scf.yield %c1, %c0 : i1, i1 scf.yield %c1, %c0 : i1, i1
} }
// CHECK: ^[[dom]](%[[arg1:.*]]: i1, %[[arg2:.*]]: i1): // CHECK: ^[[dom]](%[[arg1:.*]]: i1, %[[arg2:.*]]: i1):
// CHECK: br ^[[cont:.*]] // CHECK: cf.br ^[[cont:.*]]
// CHECK: ^[[cont]]: // CHECK: ^[[cont]]:
// CHECK: return %[[arg1]], %[[arg2]] // CHECK: return %[[arg1]], %[[arg2]]
return %0#0, %0#1 : i1, i1 return %0#0, %0#1 : i1, i1
} }
// CHECK-LABEL: func @nested_if_yield // CHECK-LABEL: func @nested_if_yield
func @nested_if_yield(%arg0: i1) -> (index) { func @nested_if_yield(%arg0: i1) -> (index) {
// CHECK: cond_br %{{.*}}, ^[[first_then:.*]], ^[[first_else:.*]] // CHECK: cf.cond_br %{{.*}}, ^[[first_then:.*]], ^[[first_else:.*]]
%0 = scf.if %arg0 -> i1 { %0 = scf.if %arg0 -> i1 {
// CHECK: ^[[first_then]]: // CHECK: ^[[first_then]]:
%1 = arith.constant true %1 = arith.constant true
// CHECK: br ^[[first_dom:.*]]({{.*}}) // CHECK: cf.br ^[[first_dom:.*]]({{.*}})
scf.yield %1 : i1 scf.yield %1 : i1
} else { } else {
// CHECK: ^[[first_else]]: // CHECK: ^[[first_else]]:
%2 = arith.constant false %2 = arith.constant false
// CHECK: br ^[[first_dom]]({{.*}}) // CHECK: cf.br ^[[first_dom]]({{.*}})
scf.yield %2 : i1 scf.yield %2 : i1
} }
// CHECK: ^[[first_dom]](%[[arg1:.*]]: i1): // CHECK: ^[[first_dom]](%[[arg1:.*]]: i1):
// CHECK: br ^[[first_cont:.*]] // CHECK: cf.br ^[[first_cont:.*]]
// CHECK: ^[[first_cont]]: // CHECK: ^[[first_cont]]:
// CHECK: cond_br %[[arg1]], ^[[second_outer_then:.*]], ^[[second_outer_else:.*]] // CHECK: cf.cond_br %[[arg1]], ^[[second_outer_then:.*]], ^[[second_outer_else:.*]]
%1 = scf.if %0 -> index { %1 = scf.if %0 -> index {
// CHECK: ^[[second_outer_then]]: // CHECK: ^[[second_outer_then]]:
// CHECK: cond_br %arg0, ^[[second_inner_then:.*]], ^[[second_inner_else:.*]] // CHECK: cf.cond_br %arg0, ^[[second_inner_then:.*]], ^[[second_inner_else:.*]]
%3 = scf.if %arg0 -> index { %3 = scf.if %arg0 -> index {
// CHECK: ^[[second_inner_then]]: // CHECK: ^[[second_inner_then]]:
%4 = arith.constant 40 : index %4 = arith.constant 40 : index
// CHECK: br ^[[second_inner_dom:.*]]({{.*}}) // CHECK: cf.br ^[[second_inner_dom:.*]]({{.*}})
scf.yield %4 : index scf.yield %4 : index
} else { } else {
// CHECK: ^[[second_inner_else]]: // CHECK: ^[[second_inner_else]]:
%5 = arith.constant 41 : index %5 = arith.constant 41 : index
// CHECK: br ^[[second_inner_dom]]({{.*}}) // CHECK: cf.br ^[[second_inner_dom]]({{.*}})
scf.yield %5 : index scf.yield %5 : index
} }
// CHECK: ^[[second_inner_dom]](%[[arg2:.*]]: index): // CHECK: ^[[second_inner_dom]](%[[arg2:.*]]: index):
// CHECK: br ^[[second_inner_cont:.*]] // CHECK: cf.br ^[[second_inner_cont:.*]]
// CHECK: ^[[second_inner_cont]]: // CHECK: ^[[second_inner_cont]]:
// CHECK: br ^[[second_outer_dom:.*]]({{.*}}) // CHECK: cf.br ^[[second_outer_dom:.*]]({{.*}})
scf.yield %3 : index scf.yield %3 : index
} else { } else {
// CHECK: ^[[second_outer_else]]: // CHECK: ^[[second_outer_else]]:
%6 = arith.constant 42 : index %6 = arith.constant 42 : index
// CHECK: br ^[[second_outer_dom]]({{.*}} // CHECK: cf.br ^[[second_outer_dom]]({{.*}}
scf.yield %6 : index scf.yield %6 : index
} }
// CHECK: ^[[second_outer_dom]](%[[arg3:.*]]: index): // CHECK: ^[[second_outer_dom]](%[[arg3:.*]]: index):
// CHECK: br ^[[second_outer_cont:.*]] // CHECK: cf.br ^[[second_outer_cont:.*]]
// CHECK: ^[[second_outer_cont]]: // CHECK: ^[[second_outer_cont]]:
// CHECK: return %[[arg3]] : index // CHECK: return %[[arg3]] : index
return %1 : index return %1 : index
} }
// CHECK-LABEL: func @parallel_loop( // CHECK-LABEL: func @parallel_loop(
// CHECK-SAME: [[VAL_0:%.*]]: index, [[VAL_1:%.*]]: index, [[VAL_2:%.*]]: index, [[VAL_3:%.*]]: index, [[VAL_4:%.*]]: index) { // CHECK-SAME: [[VAL_0:%.*]]: index, [[VAL_1:%.*]]: index, [[VAL_2:%.*]]: index, [[VAL_3:%.*]]: index, [[VAL_4:%.*]]: index) {
// CHECK: [[VAL_5:%.*]] = arith.constant 1 : index // CHECK: [[VAL_5:%.*]] = arith.constant 1 : index
// CHECK: br ^bb1([[VAL_0]] : index) // CHECK: cf.br ^bb1([[VAL_0]] : index)
// CHECK: ^bb1([[VAL_6:%.*]]: index): // CHECK: ^bb1([[VAL_6:%.*]]: index):
// CHECK: [[VAL_7:%.*]] = arith.cmpi slt, [[VAL_6]], [[VAL_2]] : index // CHECK: [[VAL_7:%.*]] = arith.cmpi slt, [[VAL_6]], [[VAL_2]] : index
// CHECK: cond_br [[VAL_7]], ^bb2, ^bb6 // CHECK: cf.cond_br [[VAL_7]], ^bb2, ^bb6
// CHECK: ^bb2: // CHECK: ^bb2:
// CHECK: br ^bb3([[VAL_1]] : index) // CHECK: cf.br ^bb3([[VAL_1]] : index)
// CHECK: ^bb3([[VAL_8:%.*]]: index): // CHECK: ^bb3([[VAL_8:%.*]]: index):
// CHECK: [[VAL_9:%.*]] = arith.cmpi slt, [[VAL_8]], [[VAL_3]] : index // CHECK: [[VAL_9:%.*]] = arith.cmpi slt, [[VAL_8]], [[VAL_3]] : index
// CHECK: cond_br [[VAL_9]], ^bb4, ^bb5 // CHECK: cf.cond_br [[VAL_9]], ^bb4, ^bb5
// CHECK: ^bb4: // CHECK: ^bb4:
// CHECK: [[VAL_10:%.*]] = arith.constant 1 : index // CHECK: [[VAL_10:%.*]] = arith.constant 1 : index
// CHECK: [[VAL_11:%.*]] = arith.addi [[VAL_8]], [[VAL_5]] : index // CHECK: [[VAL_11:%.*]] = arith.addi [[VAL_8]], [[VAL_5]] : index
// CHECK: br ^bb3([[VAL_11]] : index) // CHECK: cf.br ^bb3([[VAL_11]] : index)
// CHECK: ^bb5: // CHECK: ^bb5:
// CHECK: [[VAL_12:%.*]] = arith.addi [[VAL_6]], [[VAL_4]] : index // CHECK: [[VAL_12:%.*]] = arith.addi [[VAL_6]], [[VAL_4]] : index
// CHECK: br ^bb1([[VAL_12]] : index) // CHECK: cf.br ^bb1([[VAL_12]] : index)
// CHECK: ^bb6: // CHECK: ^bb6:
// CHECK: return // CHECK: return
// CHECK: } // CHECK: }
func @parallel_loop(%arg0 : index, %arg1 : index, %arg2 : index, func @parallel_loop(%arg0 : index, %arg1 : index, %arg2 : index,
%arg3 : index, %arg4 : index) { %arg3 : index, %arg4 : index) {
%step = arith.constant 1 : index %step = arith.constant 1 : index
scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3) scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3)
step (%arg4, %step) { step (%arg4, %step) {
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
} }
return return
} }
// CHECK-LABEL: @for_yield // CHECK-LABEL: @for_yield
// CHECK-SAME: (%[[LB:.*]]: index, %[[UB:.*]]: index, %[[STEP:.*]]: index) // CHECK-SAME: (%[[LB:.*]]: index, %[[UB:.*]]: index, %[[STEP:.*]]: index)
// CHECK: %[[INIT0:.*]] = arith.constant 0 // CHECK: %[[INIT0:.*]] = arith.constant 0
// CHECK: %[[INIT1:.*]] = arith.constant 1 // CHECK: %[[INIT1:.*]] = arith.constant 1
// CHECK: br ^[[COND:.*]](%[[LB]], %[[INIT0]], %[[INIT1]] : index, f32, f32) // CHECK: cf.br ^[[COND:.*]](%[[LB]], %[[INIT0]], %[[INIT1]] : index, f32, f32)
// //
// CHECK: ^[[COND]](%[[ITER:.*]]: index, %[[ITER_ARG0:.*]]: f32, %[[ITER_ARG1:.*]]: f32): // CHECK: ^[[COND]](%[[ITER:.*]]: index, %[[ITER_ARG0:.*]]: f32, %[[ITER_ARG1:.*]]: f32):
// CHECK: %[[CMP:.*]] = arith.cmpi slt, %[[ITER]], %[[UB]] : index // CHECK: %[[CMP:.*]] = arith.cmpi slt, %[[ITER]], %[[UB]] : index
// CHECK: cond_br %[[CMP]], ^[[BODY:.*]], ^[[CONTINUE:.*]] // CHECK: cf.cond_br %[[CMP]], ^[[BODY:.*]], ^[[CONTINUE:.*]]
// //
// CHECK: ^[[BODY]]: // CHECK: ^[[BODY]]:
// CHECK: %[[SUM:.*]] = arith.addf %[[ITER_ARG0]], %[[ITER_ARG1]] : f32 // CHECK: %[[SUM:.*]] = arith.addf %[[ITER_ARG0]], %[[ITER_ARG1]] : f32
// CHECK: %[[STEPPED:.*]] = arith.addi %[[ITER]], %[[STEP]] : index // CHECK: %[[STEPPED:.*]] = arith.addi %[[ITER]], %[[STEP]] : index
// CHECK: br ^[[COND]](%[[STEPPED]], %[[SUM]], %[[SUM]] : index, f32, f32) // CHECK: cf.br ^[[COND]](%[[STEPPED]], %[[SUM]], %[[SUM]] : index, f32, f32)
// //
// CHECK: ^[[CONTINUE]]: // CHECK: ^[[CONTINUE]]:
// CHECK: return %[[ITER_ARG0]], %[[ITER_ARG1]] : f32, f32 // CHECK: return %[[ITER_ARG0]], %[[ITER_ARG1]] : f32, f32
func @for_yield(%arg0 : index, %arg1 : index, %arg2 : index) -> (f32, f32) { func @for_yield(%arg0 : index, %arg1 : index, %arg2 : index) -> (f32, f32) {
%s0 = arith.constant 0.0 : f32 %s0 = arith.constant 0.0 : f32
%s1 = arith.constant 1.0 : f32 %s1 = arith.constant 1.0 : f32
%result:2 = scf.for %i0 = %arg0 to %arg1 step %arg2 iter_args(%si = %s0, %sj = %s1) -> (f32, f32) { %result:2 = scf.for %i0 = %arg0 to %arg1 step %arg2 iter_args(%si = %s0, %sj = %s1) -> (f32, f32) {
%sn = arith.addf %si, %sj : f32 %sn = arith.addf %si, %sj : f32
scf.yield %sn, %sn : f32, f32 scf.yield %sn, %sn : f32, f32
} }
return %result#0, %result#1 : f32, f32 return %result#0, %result#1 : f32, f32
} }
// CHECK-LABEL: @nested_for_yield // CHECK-LABEL: @nested_for_yield
// CHECK-SAME: (%[[LB:.*]]: index, %[[UB:.*]]: index, %[[STEP:.*]]: index) // CHECK-SAME: (%[[LB:.*]]: index, %[[UB:.*]]: index, %[[STEP:.*]]: index)
// CHECK: %[[INIT:.*]] = arith.constant // CHECK: %[[INIT:.*]] = arith.constant
// CHECK: br ^[[COND_OUT:.*]](%[[LB]], %[[INIT]] : index, f32) // CHECK: cf.br ^[[COND_OUT:.*]](%[[LB]], %[[INIT]] : index, f32)
// CHECK: ^[[COND_OUT]](%[[ITER_OUT:.*]]: index, %[[ARG_OUT:.*]]: f32): // CHECK: ^[[COND_OUT]](%[[ITER_OUT:.*]]: index, %[[ARG_OUT:.*]]: f32):
// CHECK: cond_br %{{.*}}, ^[[BODY_OUT:.*]], ^[[CONT_OUT:.*]] // CHECK: cf.cond_br %{{.*}}, ^[[BODY_OUT:.*]], ^[[CONT_OUT:.*]]
// CHECK: ^[[BODY_OUT]]: // CHECK: ^[[BODY_OUT]]:
// CHECK: br ^[[COND_IN:.*]](%[[LB]], %[[ARG_OUT]] : index, f32) // CHECK: cf.br ^[[COND_IN:.*]](%[[LB]], %[[ARG_OUT]] : index, f32)
// CHECK: ^[[COND_IN]](%[[ITER_IN:.*]]: index, %[[ARG_IN:.*]]: f32): // CHECK: ^[[COND_IN]](%[[ITER_IN:.*]]: index, %[[ARG_IN:.*]]: f32):
// CHECK: cond_br %{{.*}}, ^[[BODY_IN:.*]], ^[[CONT_IN:.*]] // CHECK: cf.cond_br %{{.*}}, ^[[BODY_IN:.*]], ^[[CONT_IN:.*]]
// CHECK: ^[[BODY_IN]] // CHECK: ^[[BODY_IN]]
// CHECK: %[[RES:.*]] = arith.addf // CHECK: %[[RES:.*]] = arith.addf
// CHECK: br ^[[COND_IN]](%{{.*}}, %[[RES]] : index, f32) // CHECK: cf.br ^[[COND_IN]](%{{.*}}, %[[RES]] : index, f32)
// CHECK: ^[[CONT_IN]]: // CHECK: ^[[CONT_IN]]:
// CHECK: br ^[[COND_OUT]](%{{.*}}, %[[ARG_IN]] : index, f32) // CHECK: cf.br ^[[COND_OUT]](%{{.*}}, %[[ARG_IN]] : index, f32)
// CHECK: ^[[CONT_OUT]]: // CHECK: ^[[CONT_OUT]]:
// CHECK: return %[[ARG_OUT]] : f32 // CHECK: return %[[ARG_OUT]] : f32
func @nested_for_yield(%arg0 : index, %arg1 : index, %arg2 : index) -> f32 { func @nested_for_yield(%arg0 : index, %arg1 : index, %arg2 : index) -> f32 {
%s0 = arith.constant 1.0 : f32 %s0 = arith.constant 1.0 : f32
%r = scf.for %i0 = %arg0 to %arg1 step %arg2 iter_args(%iter = %s0) -> (f32) { %r = scf.for %i0 = %arg0 to %arg1 step %arg2 iter_args(%iter = %s0) -> (f32) {
%result = scf.for %i1 = %arg0 to %arg1 step %arg2 iter_args(%si = %iter) -> (f32) { %result = scf.for %i1 = %arg0 to %arg1 step %arg2 iter_args(%si = %iter) -> (f32) {
%sn = arith.addf %si, %si : f32 %sn = arith.addf %si, %si : f32
scf.yield %sn : f32 scf.yield %sn : f32
Show All 9 Lines
// CHECK-SAME: %[[LB:.*]]: index, %[[UB:.*]]: index, %[[STEP:.*]]: index, %[[INIT:.*]]: f32 // CHECK-SAME: %[[LB:.*]]: index, %[[UB:.*]]: index, %[[STEP:.*]]: index, %[[INIT:.*]]: f32
func @simple_parallel_reduce_loop(%arg0: index, %arg1: index, func @simple_parallel_reduce_loop(%arg0: index, %arg1: index,
%arg2: index, %arg3: f32) -> f32 { %arg2: index, %arg3: f32) -> f32 {
// A parallel loop with reduction is converted through sequential loops with // A parallel loop with reduction is converted through sequential loops with
// reductions into a CFG of blocks where the partially reduced value is // reductions into a CFG of blocks where the partially reduced value is
// passed across as a block argument. // passed across as a block argument.
// Branch to the condition block passing in the initial reduction value. // Branch to the condition block passing in the initial reduction value.
// CHECK: br ^[[COND:.*]](%[[LB]], %[[INIT]] // CHECK: cf.br ^[[COND:.*]](%[[LB]], %[[INIT]]
// Condition branch takes as arguments the current value of the iteration // Condition branch takes as arguments the current value of the iteration
// variable and the current partially reduced value. // variable and the current partially reduced value.
// CHECK: ^[[COND]](%[[ITER:.*]]: index, %[[ITER_ARG:.*]]: f32 // CHECK: ^[[COND]](%[[ITER:.*]]: index, %[[ITER_ARG:.*]]: f32
// CHECK: %[[COMP:.*]] = arith.cmpi slt, %[[ITER]], %[[UB]] // CHECK: %[[COMP:.*]] = arith.cmpi slt, %[[ITER]], %[[UB]]
// CHECK: cond_br %[[COMP]], ^[[BODY:.*]], ^[[CONTINUE:.*]] // CHECK: cf.cond_br %[[COMP]], ^[[BODY:.*]], ^[[CONTINUE:.*]]
// Bodies of scf.reduce operations are folded into the main loop body. The // Bodies of scf.reduce operations are folded into the main loop body. The
// result of this partial reduction is passed as argument to the condition // result of this partial reduction is passed as argument to the condition
// block. // block.
// CHECK: ^[[BODY]]: // CHECK: ^[[BODY]]:
// CHECK: %[[CST:.*]] = arith.constant 4.2 // CHECK: %[[CST:.*]] = arith.constant 4.2
// CHECK: %[[PROD:.*]] = arith.mulf %[[ITER_ARG]], %[[CST]] // CHECK: %[[PROD:.*]] = arith.mulf %[[ITER_ARG]], %[[CST]]
// CHECK: %[[INCR:.*]] = arith.addi %[[ITER]], %[[STEP]] // CHECK: %[[INCR:.*]] = arith.addi %[[ITER]], %[[STEP]]
// CHECK: br ^[[COND]](%[[INCR]], %[[PROD]] // CHECK: cf.br ^[[COND]](%[[INCR]], %[[PROD]]
// The continuation block has access to the (last value of) reduction. // The continuation block has access to the (last value of) reduction.
// CHECK: ^[[CONTINUE]]: // CHECK: ^[[CONTINUE]]:
// CHECK: return %[[ITER_ARG]] // CHECK: return %[[ITER_ARG]]
%0 = scf.parallel (%i) = (%arg0) to (%arg1) step (%arg2) init(%arg3) -> f32 { %0 = scf.parallel (%i) = (%arg0) to (%arg1) step (%arg2) init(%arg3) -> f32 {
%cst = arith.constant 42.0 : f32 %cst = arith.constant 42.0 : f32
scf.reduce(%cst) : f32 { scf.reduce(%cst) : f32 {
^bb0(%lhs: f32, %rhs: f32): ^bb0(%lhs: f32, %rhs: f32):
%1 = arith.mulf %lhs, %rhs : f32 %1 = arith.mulf %lhs, %rhs : f32
scf.reduce.return %1 : f32 scf.reduce.return %1 : f32
} }
} }
return %0 : f32 return %0 : f32
} }
// CHECK-LABEL: parallel_reduce_loop // CHECK-LABEL: parallel_reduce_loop
// CHECK-SAME: %[[INIT1:[0-9A-Za-z_]*]]: f32) // CHECK-SAME: %[[INIT1:[0-9A-Za-z_]*]]: f32)
func @parallel_reduce_loop(%arg0 : index, %arg1 : index, %arg2 : index, func @parallel_reduce_loop(%arg0 : index, %arg1 : index, %arg2 : index,
%arg3 : index, %arg4 : index, %arg5 : f32) -> (f32, i64) { %arg3 : index, %arg4 : index, %arg5 : f32) -> (f32, i64) {
// Multiple reduction blocks should be folded in the same body, and the // Multiple reduction blocks should be folded in the same body, and the
// reduction value must be forwarded through block structures. // reduction value must be forwarded through block structures.
// CHECK: %[[INIT2:.*]] = arith.constant 42 // CHECK: %[[INIT2:.*]] = arith.constant 42
// CHECK: br ^[[COND_OUT:.*]](%{{.*}}, %[[INIT1]], %[[INIT2]] // CHECK: cf.br ^[[COND_OUT:.*]](%{{.*}}, %[[INIT1]], %[[INIT2]]
// CHECK: ^[[COND_OUT]](%{{.*}}: index, %[[ITER_ARG1_OUT:.*]]: f32, %[[ITER_ARG2_OUT:.*]]: i64 // CHECK: ^[[COND_OUT]](%{{.*}}: index, %[[ITER_ARG1_OUT:.*]]: f32, %[[ITER_ARG2_OUT:.*]]: i64
// CHECK: cond_br %{{.*}}, ^[[BODY_OUT:.*]], ^[[CONT_OUT:.*]] // CHECK: cf.cond_br %{{.*}}, ^[[BODY_OUT:.*]], ^[[CONT_OUT:.*]]
// CHECK: ^[[BODY_OUT]]: // CHECK: ^[[BODY_OUT]]:
// CHECK: br ^[[COND_IN:.*]](%{{.*}}, %[[ITER_ARG1_OUT]], %[[ITER_ARG2_OUT]] // CHECK: cf.br ^[[COND_IN:.*]](%{{.*}}, %[[ITER_ARG1_OUT]], %[[ITER_ARG2_OUT]]
// CHECK: ^[[COND_IN]](%{{.*}}: index, %[[ITER_ARG1_IN:.*]]: f32, %[[ITER_ARG2_IN:.*]]: i64 // CHECK: ^[[COND_IN]](%{{.*}}: index, %[[ITER_ARG1_IN:.*]]: f32, %[[ITER_ARG2_IN:.*]]: i64
// CHECK: cond_br %{{.*}}, ^[[BODY_IN:.*]], ^[[CONT_IN:.*]] // CHECK: cf.cond_br %{{.*}}, ^[[BODY_IN:.*]], ^[[CONT_IN:.*]]
// CHECK: ^[[BODY_IN]]: // CHECK: ^[[BODY_IN]]:
// CHECK: %[[REDUCE1:.*]] = arith.addf %[[ITER_ARG1_IN]], %{{.*}} // CHECK: %[[REDUCE1:.*]] = arith.addf %[[ITER_ARG1_IN]], %{{.*}}
// CHECK: %[[REDUCE2:.*]] = arith.ori %[[ITER_ARG2_IN]], %{{.*}} // CHECK: %[[REDUCE2:.*]] = arith.ori %[[ITER_ARG2_IN]], %{{.*}}
// CHECK: br ^[[COND_IN]](%{{.*}}, %[[REDUCE1]], %[[REDUCE2]] // CHECK: cf.br ^[[COND_IN]](%{{.*}}, %[[REDUCE1]], %[[REDUCE2]]
// CHECK: ^[[CONT_IN]]: // CHECK: ^[[CONT_IN]]:
// CHECK: br ^[[COND_OUT]](%{{.*}}, %[[ITER_ARG1_IN]], %[[ITER_ARG2_IN]] // CHECK: cf.br ^[[COND_OUT]](%{{.*}}, %[[ITER_ARG1_IN]], %[[ITER_ARG2_IN]]
// CHECK: ^[[CONT_OUT]]: // CHECK: ^[[CONT_OUT]]:
// CHECK: return %[[ITER_ARG1_OUT]], %[[ITER_ARG2_OUT]] // CHECK: return %[[ITER_ARG1_OUT]], %[[ITER_ARG2_OUT]]
%step = arith.constant 1 : index %step = arith.constant 1 : index
%init = arith.constant 42 : i64 %init = arith.constant 42 : i64
%0:2 = scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3) %0:2 = scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3)
step (%arg4, %step) init(%arg5, %init) -> (f32, i64) { step (%arg4, %step) init(%arg5, %init) -> (f32, i64) {
%cf = arith.constant 42.0 : f32 %cf = arith.constant 42.0 : f32
scf.reduce(%cf) : f32 { scf.reduce(%cf) : f32 {
Show All 24 Lines scf.for %i = %arg0 to %arg1 step %arg2 {
scf.yield scf.yield
} }
return return
} }
// CHECK-LABEL: @minimal_while // CHECK-LABEL: @minimal_while
func @minimal_while() { func @minimal_while() {
// CHECK: %[[COND:.*]] = "test.make_condition"() : () -> i1 // CHECK: %[[COND:.*]] = "test.make_condition"() : () -> i1
// CHECK: br ^[[BEFORE:.*]] // CHECK: cf.br ^[[BEFORE:.*]]
%0 = "test.make_condition"() : () -> i1 %0 = "test.make_condition"() : () -> i1
scf.while : () -> () { scf.while : () -> () {
// CHECK: ^[[BEFORE]]: // CHECK: ^[[BEFORE]]:
// CHECK: cond_br %[[COND]], ^[[AFTER:.*]], ^[[CONT:.*]] // CHECK: cf.cond_br %[[COND]], ^[[AFTER:.*]], ^[[CONT:.*]]
scf.condition(%0) scf.condition(%0)
} do { } do {
// CHECK: ^[[AFTER]]: // CHECK: ^[[AFTER]]:
// CHECK: "test.some_payload"() : () -> () // CHECK: "test.some_payload"() : () -> ()
"test.some_payload"() : () -> () "test.some_payload"() : () -> ()
// CHECK: br ^[[BEFORE]] // CHECK: cf.br ^[[BEFORE]]
scf.yield scf.yield
} }
// CHECK: ^[[CONT]]: // CHECK: ^[[CONT]]:
// CHECK: return // CHECK: return
return return
} }
// CHECK-LABEL: @do_while // CHECK-LABEL: @do_while
func @do_while(%arg0: f32) { func @do_while(%arg0: f32) {
// CHECK: br ^[[BEFORE:.*]]({{.*}}: f32) // CHECK: cf.br ^[[BEFORE:.*]]({{.*}}: f32)
scf.while (%arg1 = %arg0) : (f32) -> (f32) { scf.while (%arg1 = %arg0) : (f32) -> (f32) {
// CHECK: ^[[BEFORE]](%[[VAL:.*]]: f32): // CHECK: ^[[BEFORE]](%[[VAL:.*]]: f32):
// CHECK: %[[COND:.*]] = "test.make_condition"() : () -> i1 // CHECK: %[[COND:.*]] = "test.make_condition"() : () -> i1
%0 = "test.make_condition"() : () -> i1 %0 = "test.make_condition"() : () -> i1
// CHECK: cond_br %[[COND]], ^[[BEFORE]](%[[VAL]] : f32), ^[[CONT:.*]] // CHECK: cf.cond_br %[[COND]], ^[[BEFORE]](%[[VAL]] : f32), ^[[CONT:.*]]
scf.condition(%0) %arg1 : f32 scf.condition(%0) %arg1 : f32
} do { } do {
^bb0(%arg2: f32): ^bb0(%arg2: f32):
// CHECK-NOT: br ^[[BEFORE]] // CHECK-NOT: cf.br ^[[BEFORE]]
scf.yield %arg2 : f32 scf.yield %arg2 : f32
} }
// CHECK: ^[[CONT]]: // CHECK: ^[[CONT]]:
// CHECK: return // CHECK: return
return return
} }
// CHECK-LABEL: @while_values // CHECK-LABEL: @while_values
// CHECK-SAME: (%[[ARG0:.*]]: i32, %[[ARG1:.*]]: f32) // CHECK-SAME: (%[[ARG0:.*]]: i32, %[[ARG1:.*]]: f32)
func @while_values(%arg0: i32, %arg1: f32) { func @while_values(%arg0: i32, %arg1: f32) {
// CHECK: %[[COND:.*]] = "test.make_condition"() : () -> i1 // CHECK: %[[COND:.*]] = "test.make_condition"() : () -> i1
%0 = "test.make_condition"() : () -> i1 %0 = "test.make_condition"() : () -> i1
%c0_i32 = arith.constant 0 : i32 %c0_i32 = arith.constant 0 : i32
%cst = arith.constant 0.000000e+00 : f32 %cst = arith.constant 0.000000e+00 : f32
// CHECK: br ^[[BEFORE:.*]](%[[ARG0]], %[[ARG1]] : i32, f32) // CHECK: cf.br ^[[BEFORE:.*]](%[[ARG0]], %[[ARG1]] : i32, f32)
%1:2 = scf.while (%arg2 = %arg0, %arg3 = %arg1) : (i32, f32) -> (i64, f64) { %1:2 = scf.while (%arg2 = %arg0, %arg3 = %arg1) : (i32, f32) -> (i64, f64) {
// CHECK: ^bb1(%[[ARG2:.*]]: i32, %[[ARG3:.]]: f32): // CHECK: ^bb1(%[[ARG2:.*]]: i32, %[[ARG3:.]]: f32):
// CHECK: %[[VAL1:.*]] = arith.extui %[[ARG0]] : i32 to i64 // CHECK: %[[VAL1:.*]] = arith.extui %[[ARG0]] : i32 to i64
%2 = arith.extui %arg0 : i32 to i64 %2 = arith.extui %arg0 : i32 to i64
// CHECK: %[[VAL2:.*]] = arith.extf %[[ARG3]] : f32 to f64 // CHECK: %[[VAL2:.*]] = arith.extf %[[ARG3]] : f32 to f64
%3 = arith.extf %arg3 : f32 to f64 %3 = arith.extf %arg3 : f32 to f64
// CHECK: cond_br %[[COND]], // CHECK: cf.cond_br %[[COND]],
// CHECK: ^[[AFTER:.*]](%[[VAL1]], %[[VAL2]] : i64, f64), // CHECK: ^[[AFTER:.*]](%[[VAL1]], %[[VAL2]] : i64, f64),
// CHECK: ^[[CONT:.*]] // CHECK: ^[[CONT:.*]]
scf.condition(%0) %2, %3 : i64, f64 scf.condition(%0) %2, %3 : i64, f64
} do { } do {
// CHECK: ^[[AFTER]](%[[ARG4:.*]]: i64, %[[ARG5:.*]]: f64): // CHECK: ^[[AFTER]](%[[ARG4:.*]]: i64, %[[ARG5:.*]]: f64):
^bb0(%arg2: i64, %arg3: f64): ^bb0(%arg2: i64, %arg3: f64):
// CHECK: br ^[[BEFORE]](%{{.*}}, %{{.*}} : i32, f32) // CHECK: cf.br ^[[BEFORE]](%{{.*}}, %{{.*}} : i32, f32)
scf.yield %c0_i32, %cst : i32, f32 scf.yield %c0_i32, %cst : i32, f32
} }
// CHECK: ^bb3: // CHECK: ^bb3:
// CHECK: return // CHECK: return
return return
} }
// CHECK-LABEL: @nested_while_ops // CHECK-LABEL: @nested_while_ops
func @nested_while_ops(%arg0: f32) -> i64 { func @nested_while_ops(%arg0: f32) -> i64 {
// CHECK: br ^[[OUTER_BEFORE:.*]](%{{.*}} : f32) // CHECK: cf.br ^[[OUTER_BEFORE:.*]](%{{.*}} : f32)
%0 = scf.while(%outer = %arg0) : (f32) -> i64 { %0 = scf.while(%outer = %arg0) : (f32) -> i64 {
// CHECK: ^[[OUTER_BEFORE]](%{{.*}}: f32): // CHECK: ^[[OUTER_BEFORE]](%{{.*}}: f32):
// CHECK: %[[OUTER_COND:.*]] = "test.outer_before_pre"() : () -> i1 // CHECK: %[[OUTER_COND:.*]] = "test.outer_before_pre"() : () -> i1
%cond = "test.outer_before_pre"() : () -> i1 %cond = "test.outer_before_pre"() : () -> i1
// CHECK: br ^[[INNER_BEFORE_BEFORE:.*]](%{{.*}} : f32) // CHECK: cf.br ^[[INNER_BEFORE_BEFORE:.*]](%{{.*}} : f32)
%1 = scf.while(%inner = %outer) : (f32) -> i64 { %1 = scf.while(%inner = %outer) : (f32) -> i64 {
// CHECK: ^[[INNER_BEFORE_BEFORE]](%{{.*}}: f32): // CHECK: ^[[INNER_BEFORE_BEFORE]](%{{.*}}: f32):
// CHECK: %[[INNER1:.*]]:2 = "test.inner_before"(%{{.*}}) : (f32) -> (i1, i64) // CHECK: %[[INNER1:.*]]:2 = "test.inner_before"(%{{.*}}) : (f32) -> (i1, i64)
%2:2 = "test.inner_before"(%inner) : (f32) -> (i1, i64) %2:2 = "test.inner_before"(%inner) : (f32) -> (i1, i64)
// CHECK: cond_br %[[INNER1]]#0, // CHECK: cf.cond_br %[[INNER1]]#0,
// CHECK: ^[[INNER_BEFORE_AFTER:.*]](%[[INNER1]]#1 : i64), // CHECK: ^[[INNER_BEFORE_AFTER:.*]](%[[INNER1]]#1 : i64),
// CHECK: ^[[OUTER_BEFORE_LAST:.*]] // CHECK: ^[[OUTER_BEFORE_LAST:.*]]
scf.condition(%2#0) %2#1 : i64 scf.condition(%2#0) %2#1 : i64
} do { } do {
// CHECK: ^[[INNER_BEFORE_AFTER]](%{{.*}}: i64): // CHECK: ^[[INNER_BEFORE_AFTER]](%{{.*}}: i64):
^bb0(%arg1: i64): ^bb0(%arg1: i64):
// CHECK: %[[INNER2:.*]] = "test.inner_after"(%{{.*}}) : (i64) -> f32 // CHECK: %[[INNER2:.*]] = "test.inner_after"(%{{.*}}) : (i64) -> f32
%3 = "test.inner_after"(%arg1) : (i64) -> f32 %3 = "test.inner_after"(%arg1) : (i64) -> f32
// CHECK: br ^[[INNER_BEFORE_BEFORE]](%[[INNER2]] : f32) // CHECK: cf.br ^[[INNER_BEFORE_BEFORE]](%[[INNER2]] : f32)
scf.yield %3 : f32 scf.yield %3 : f32
} }
// CHECK: ^[[OUTER_BEFORE_LAST]]: // CHECK: ^[[OUTER_BEFORE_LAST]]:
// CHECK: "test.outer_before_post"() : () -> () // CHECK: "test.outer_before_post"() : () -> ()
"test.outer_before_post"() : () -> () "test.outer_before_post"() : () -> ()
// CHECK: cond_br %[[OUTER_COND]], // CHECK: cf.cond_br %[[OUTER_COND]],
// CHECK: ^[[OUTER_AFTER:.*]](%[[INNER1]]#1 : i64), // CHECK: ^[[OUTER_AFTER:.*]](%[[INNER1]]#1 : i64),
// CHECK: ^[[CONTINUATION:.*]] // CHECK: ^[[CONTINUATION:.*]]
scf.condition(%cond) %1 : i64 scf.condition(%cond) %1 : i64
} do { } do {
// CHECK: ^[[OUTER_AFTER]](%{{.*}}: i64): // CHECK: ^[[OUTER_AFTER]](%{{.*}}: i64):
^bb2(%arg2: i64): ^bb2(%arg2: i64):
// CHECK: "test.outer_after_pre"(%{{.*}}) : (i64) -> () // CHECK: "test.outer_after_pre"(%{{.*}}) : (i64) -> ()
"test.outer_after_pre"(%arg2) : (i64) -> () "test.outer_after_pre"(%arg2) : (i64) -> ()
// CHECK: br ^[[INNER_AFTER_BEFORE:.*]](%{{.*}} : i64) // CHECK: cf.br ^[[INNER_AFTER_BEFORE:.*]](%{{.*}} : i64)
%4 = scf.while(%inner = %arg2) : (i64) -> f32 { %4 = scf.while(%inner = %arg2) : (i64) -> f32 {
// CHECK: ^[[INNER_AFTER_BEFORE]](%{{.*}}: i64): // CHECK: ^[[INNER_AFTER_BEFORE]](%{{.*}}: i64):
// CHECK: %[[INNER3:.*]]:2 = "test.inner2_before"(%{{.*}}) : (i64) -> (i1, f32) // CHECK: %[[INNER3:.*]]:2 = "test.inner2_before"(%{{.*}}) : (i64) -> (i1, f32)
%5:2 = "test.inner2_before"(%inner) : (i64) -> (i1, f32) %5:2 = "test.inner2_before"(%inner) : (i64) -> (i1, f32)
// CHECK: cond_br %[[INNER3]]#0, // CHECK: cf.cond_br %[[INNER3]]#0,
// CHECK: ^[[INNER_AFTER_AFTER:.*]](%[[INNER3]]#1 : f32), // CHECK: ^[[INNER_AFTER_AFTER:.*]](%[[INNER3]]#1 : f32),
// CHECK: ^[[OUTER_AFTER_LAST:.*]] // CHECK: ^[[OUTER_AFTER_LAST:.*]]
scf.condition(%5#0) %5#1 : f32 scf.condition(%5#0) %5#1 : f32
} do { } do {
// CHECK: ^[[INNER_AFTER_AFTER]](%{{.*}}: f32): // CHECK: ^[[INNER_AFTER_AFTER]](%{{.*}}: f32):
^bb3(%arg3: f32): ^bb3(%arg3: f32):
// CHECK: %{{.*}} = "test.inner2_after"(%{{.*}}) : (f32) -> i64 // CHECK: %{{.*}} = "test.inner2_after"(%{{.*}}) : (f32) -> i64
%6 = "test.inner2_after"(%arg3) : (f32) -> i64 %6 = "test.inner2_after"(%arg3) : (f32) -> i64
// CHECK: br ^[[INNER_AFTER_BEFORE]](%{{.*}} : i64) // CHECK: cf.br ^[[INNER_AFTER_BEFORE]](%{{.*}} : i64)
scf.yield %6 : i64 scf.yield %6 : i64
} }
// CHECK: ^[[OUTER_AFTER_LAST]]: // CHECK: ^[[OUTER_AFTER_LAST]]:
// CHECK: "test.outer_after_post"() : () -> () // CHECK: "test.outer_after_post"() : () -> ()
"test.outer_after_post"() : () -> () "test.outer_after_post"() : () -> ()
// CHECK: br ^[[OUTER_BEFORE]](%[[INNER3]]#1 : f32) // CHECK: cf.br ^[[OUTER_BEFORE]](%[[INNER3]]#1 : f32)
scf.yield %4 : f32 scf.yield %4 : f32
} }
// CHECK: ^[[CONTINUATION]]: // CHECK: ^[[CONTINUATION]]:
// CHECK: return %{{.*}} : i64 // CHECK: return %{{.*}} : i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: @ifs_in_parallel // CHECK-LABEL: @ifs_in_parallel
// CHECK: (%[[ARG0:.*]]: index, %[[ARG1:.*]]: index, %[[ARG2:.*]]: index, %[[ARG3:.*]]: i1, %[[ARG4:.*]]: i1) // CHECK: (%[[ARG0:.*]]: index, %[[ARG1:.*]]: index, %[[ARG2:.*]]: index, %[[ARG3:.*]]: i1, %[[ARG4:.*]]: i1)
func @ifs_in_parallel(%arg1: index, %arg2: index, %arg3: index, %arg4: i1, %arg5: i1) { func @ifs_in_parallel(%arg1: index, %arg2: index, %arg3: index, %arg4: i1, %arg5: i1) {
// CHECK: br ^[[LOOP_LATCH:.*]](%[[ARG0]] : index) // CHECK: cf.br ^[[LOOP_LATCH:.*]](%[[ARG0]] : index)
// CHECK: ^[[LOOP_LATCH]](%[[LOOP_IV:.*]]: index): // CHECK: ^[[LOOP_LATCH]](%[[LOOP_IV:.*]]: index):
// CHECK: %[[LOOP_COND:.*]] = arith.cmpi slt, %[[LOOP_IV]], %[[ARG1]] : index // CHECK: %[[LOOP_COND:.*]] = arith.cmpi slt, %[[LOOP_IV]], %[[ARG1]] : index
// CHECK: cond_br %[[LOOP_COND]], ^[[LOOP_BODY:.*]], ^[[LOOP_CONT:.*]] // CHECK: cf.cond_br %[[LOOP_COND]], ^[[LOOP_BODY:.*]], ^[[LOOP_CONT:.*]]
// CHECK: ^[[LOOP_BODY]]: // CHECK: ^[[LOOP_BODY]]:
// CHECK: cond_br %[[ARG3]], ^[[IF1_THEN:.*]], ^[[IF1_CONT:.*]] // CHECK: cf.cond_br %[[ARG3]], ^[[IF1_THEN:.*]], ^[[IF1_CONT:.*]]
// CHECK: ^[[IF1_THEN]]: // CHECK: ^[[IF1_THEN]]:
// CHECK: cond_br %[[ARG4]], ^[[IF2_THEN:.*]], ^[[IF2_ELSE:.*]] // CHECK: cf.cond_br %[[ARG4]], ^[[IF2_THEN:.*]], ^[[IF2_ELSE:.*]]
// CHECK: ^[[IF2_THEN]]: // CHECK: ^[[IF2_THEN]]:
// CHECK: %{{.*}} = "test.if2"() : () -> index // CHECK: %{{.*}} = "test.if2"() : () -> index
// CHECK: br ^[[IF2_MERGE:.*]](%{{.*}} : index) // CHECK: cf.br ^[[IF2_MERGE:.*]](%{{.*}} : index)
// CHECK: ^[[IF2_ELSE]]: // CHECK: ^[[IF2_ELSE]]:
// CHECK: %{{.*}} = "test.else2"() : () -> index // CHECK: %{{.*}} = "test.else2"() : () -> index
// CHECK: br ^[[IF2_MERGE]](%{{.*}} : index) // CHECK: cf.br ^[[IF2_MERGE]](%{{.*}} : index)
// CHECK: ^[[IF2_MERGE]](%{{.*}}: index): // CHECK: ^[[IF2_MERGE]](%{{.*}}: index):
// CHECK: br ^[[IF2_CONT:.*]] // CHECK: cf.br ^[[IF2_CONT:.*]]
// CHECK: ^[[IF2_CONT]]: // CHECK: ^[[IF2_CONT]]:
// CHECK: br ^[[IF1_CONT]] // CHECK: cf.br ^[[IF1_CONT]]
// CHECK: ^[[IF1_CONT]]: // CHECK: ^[[IF1_CONT]]:
// CHECK: %{{.*}} = arith.addi %[[LOOP_IV]], %[[ARG2]] : index // CHECK: %{{.*}} = arith.addi %[[LOOP_IV]], %[[ARG2]] : index
// CHECK: br ^[[LOOP_LATCH]](%{{.*}} : index) // CHECK: cf.br ^[[LOOP_LATCH]](%{{.*}} : index)
scf.parallel (%i) = (%arg1) to (%arg2) step (%arg3) { scf.parallel (%i) = (%arg1) to (%arg2) step (%arg3) {
scf.if %arg4 { scf.if %arg4 {
%0 = scf.if %arg5 -> (index) { %0 = scf.if %arg5 -> (index) {
%1 = "test.if2"() : () -> index %1 = "test.if2"() : () -> index
scf.yield %1 : index scf.yield %1 : index
} else { } else {
%2 = "test.else2"() : () -> index %2 = "test.else2"() : () -> index
scf.yield %2 : index scf.yield %2 : index
} }
} }
scf.yield scf.yield
} }
// CHECK: ^[[LOOP_CONT]]: // CHECK: ^[[LOOP_CONT]]:
// CHECK: return // CHECK: return
return return
} }
// CHECK-LABEL: func @func_execute_region_elim_multi_yield // CHECK-LABEL: func @func_execute_region_elim_multi_yield
func @func_execute_region_elim_multi_yield() { func @func_execute_region_elim_multi_yield() {
"test.foo"() : () -> () "test.foo"() : () -> ()
%v = scf.execute_region -> i64 { %v = scf.execute_region -> i64 {
%c = "test.cmp"() : () -> i1 %c = "test.cmp"() : () -> i1
cond_br %c, ^bb2, ^bb3 cf.cond_br %c, ^bb2, ^bb3
^bb2: ^bb2:
%x = "test.val1"() : () -> i64 %x = "test.val1"() : () -> i64
scf.yield %x : i64 scf.yield %x : i64
^bb3: ^bb3:
%y = "test.val2"() : () -> i64 %y = "test.val2"() : () -> i64
scf.yield %y : i64 scf.yield %y : i64
} }
"test.bar"(%v) : (i64) -> () "test.bar"(%v) : (i64) -> ()
return return
} }
// CHECK-NOT: execute_region // CHECK-NOT: execute_region
// CHECK: "test.foo" // CHECK: "test.foo"
// CHECK: br ^[[rentry:.+]] // CHECK: cf.br ^[[rentry:.+]]
// CHECK: ^[[rentry]] // CHECK: ^[[rentry]]
// CHECK: %[[cmp:.+]] = "test.cmp" // CHECK: %[[cmp:.+]] = "test.cmp"
// CHECK: cond_br %[[cmp]], ^[[bb1:.+]], ^[[bb2:.+]] // CHECK: cf.cond_br %[[cmp]], ^[[bb1:.+]], ^[[bb2:.+]]
// CHECK: ^[[bb1]]: // CHECK: ^[[bb1]]:
// CHECK: %[[x:.+]] = "test.val1" // CHECK: %[[x:.+]] = "test.val1"
// CHECK: br ^[[bb3:.+]](%[[x]] : i64) // CHECK: cf.br ^[[bb3:.+]](%[[x]] : i64)
// CHECK: ^[[bb2]]: // CHECK: ^[[bb2]]:
// CHECK: %[[y:.+]] = "test.val2" // CHECK: %[[y:.+]] = "test.val2"
// CHECK: br ^[[bb3]](%[[y:.+]] : i64) // CHECK: cf.br ^[[bb3]](%[[y:.+]] : i64)
// CHECK: ^[[bb3]](%[[z:.+]]: i64): // CHECK: ^[[bb3]](%[[z:.+]]: i64):
// CHECK: "test.bar"(%[[z]]) // CHECK: "test.bar"(%[[z]])
// CHECK: return // CHECK: return

mlir/test/Conversion/SCFToStandard/convert-to-cfg.mlir

  • This file was moved to mlir/test/Conversion/SCFToControlFlow/convert-to-cfg.mlir.

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

// RUN: mlir-opt -convert-shape-constraints <%s | FileCheck %s // RUN: mlir-opt -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: assert %[[BROADCAST_IS_VALID]], "required broadcastable shapes" // CHECK: cf.assert %[[BROADCAST_IS_VALID]], "required broadcastable shapes"
// CHECK: return %[[RET]] : !shape.witness // CHECK: return %[[RET]] : !shape.witness
// CHECK: } // CHECK: }
func @cstr_broadcastable(%arg0: tensor<?xindex>, %arg1: tensor<?xindex>) -> !shape.witness { func @cstr_broadcastable(%arg0: tensor<?xindex>, %arg1: tensor<?xindex>) -> !shape.witness {
%witness = shape.cstr_broadcastable %arg0, %arg1 : tensor<?xindex>, tensor<?xindex> %witness = shape.cstr_broadcastable %arg0, %arg1 : tensor<?xindex>, tensor<?xindex>
return %witness : !shape.witness return %witness : !shape.witness
} }
// CHECK-LABEL: func @cstr_eq( // CHECK-LABEL: func @cstr_eq(
// 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: %[[EQUAL_IS_VALID:.*]] = shape.shape_eq %[[LHS]], %[[RHS]] // CHECK: %[[EQUAL_IS_VALID:.*]] = shape.shape_eq %[[LHS]], %[[RHS]]
// CHECK: assert %[[EQUAL_IS_VALID]], "required equal shapes" // CHECK: cf.assert %[[EQUAL_IS_VALID]], "required equal shapes"
// CHECK: return %[[RET]] : !shape.witness // CHECK: return %[[RET]] : !shape.witness
// CHECK: } // CHECK: }
func @cstr_eq(%arg0: tensor<?xindex>, %arg1: tensor<?xindex>) -> !shape.witness { func @cstr_eq(%arg0: tensor<?xindex>, %arg1: tensor<?xindex>) -> !shape.witness {
%witness = shape.cstr_eq %arg0, %arg1 : tensor<?xindex>, tensor<?xindex> %witness = shape.cstr_eq %arg0, %arg1 : tensor<?xindex>, tensor<?xindex>
return %witness : !shape.witness return %witness : !shape.witness
} }
// CHECK-LABEL: func @cstr_require // CHECK-LABEL: func @cstr_require
func @cstr_require(%arg0: i1) -> !shape.witness { func @cstr_require(%arg0: i1) -> !shape.witness {
// CHECK: %[[RET:.*]] = shape.const_witness true // CHECK: %[[RET:.*]] = shape.const_witness true
// CHECK: assert %arg0, "msg" // CHECK: cf.assert %arg0, "msg"
// CHECK: return %[[RET]] // CHECK: return %[[RET]]
%witness = shape.cstr_require %arg0, "msg" %witness = shape.cstr_require %arg0, "msg"
return %witness : !shape.witness return %witness : !shape.witness
} }

mlir/test/Conversion/StandardToLLVM/convert-funcs.mlir

Show All 23 Lines
// Same in nested functions. // Same in nested functions.
// CHECK: llvm.func @memref_call_conv_nested(!llvm.ptr<func<void (ptr<f32>, ptr<f32>, i64, i64, i64)>>) // CHECK: llvm.func @memref_call_conv_nested(!llvm.ptr<func<void (ptr<f32>, ptr<f32>, i64, i64, i64)>>)
func private @memref_call_conv_nested(%arg0: (memref<?xf32>) -> ()) func private @memref_call_conv_nested(%arg0: (memref<?xf32>) -> ())
//CHECK-LABEL: llvm.func @pass_through(%arg0: !llvm.ptr<func<void ()>>) -> !llvm.ptr<func<void ()>> { //CHECK-LABEL: llvm.func @pass_through(%arg0: !llvm.ptr<func<void ()>>) -> !llvm.ptr<func<void ()>> {
func @pass_through(%arg0: () -> ()) -> (() -> ()) { func @pass_through(%arg0: () -> ()) -> (() -> ()) {
// CHECK-NEXT: llvm.br ^bb1(%arg0 : !llvm.ptr<func<void ()>>) // CHECK-NEXT: llvm.br ^bb1(%arg0 : !llvm.ptr<func<void ()>>)
br ^bb1(%arg0 : () -> ()) cf.br ^bb1(%arg0 : () -> ())
//CHECK-NEXT: ^bb1(%0: !llvm.ptr<func<void ()>>): //CHECK-NEXT: ^bb1(%0: !llvm.ptr<func<void ()>>):
^bb1(%bbarg: () -> ()): ^bb1(%bbarg: () -> ()):
// CHECK-NEXT: llvm.return %0 : !llvm.ptr<func<void ()>> // CHECK-NEXT: llvm.return %0 : !llvm.ptr<func<void ()>>
return %bbarg : () -> () return %bbarg : () -> ()
} }
// CHECK-LABEL: llvm.func extern_weak @llvmlinkage(i32) // CHECK-LABEL: llvm.func extern_weak @llvmlinkage(i32)
Show All 27 Lines

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

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Lines
!base_type = type memref<64xi32, 201> !base_type = type memref<64xi32, 201>
// CHECK-LABEL: func @loop_carried // CHECK-LABEL: func @loop_carried
// BAREPTR-LABEL: func @loop_carried // BAREPTR-LABEL: func @loop_carried
func @loop_carried(%arg0 : index, %arg1 : index, %arg2 : index, %base0 : !base_type, %base1 : !base_type) -> (!base_type, !base_type) { func @loop_carried(%arg0 : index, %arg1 : index, %arg2 : index, %base0 : !base_type, %base1 : !base_type) -> (!base_type, !base_type) {
// This test checks that in the BAREPTR case, the branch arguments only forward the descriptor. // This test checks that in the BAREPTR case, the branch arguments only forward the descriptor.
// This test was lowered from a simple scf.for that swaps 2 memref iter_args. // This test was lowered from a simple scf.for that swaps 2 memref iter_args.
// BAREPTR: llvm.br ^bb1(%{{.*}}, %{{.*}}, %{{.*}} : i64, !llvm.struct<(ptr<i32, 201>, ptr<i32, 201>, i64, array<1 x i64>, array<1 x i64>)>, !llvm.struct<(ptr<i32, 201>, ptr<i32, 201>, i64, array<1 x i64>, array<1 x i64>)>) // BAREPTR: llvm.br ^bb1(%{{.*}}, %{{.*}}, %{{.*}} : i64, !llvm.struct<(ptr<i32, 201>, ptr<i32, 201>, i64, array<1 x i64>, array<1 x i64>)>, !llvm.struct<(ptr<i32, 201>, ptr<i32, 201>, i64, array<1 x i64>, array<1 x i64>)>)
br ^bb1(%arg0, %base0, %base1 : index, memref<64xi32, 201>, memref<64xi32, 201>) cf.br ^bb1(%arg0, %base0, %base1 : index, memref<64xi32, 201>, memref<64xi32, 201>)
// BAREPTR-NEXT: ^bb1 // BAREPTR-NEXT: ^bb1
// BAREPTR-NEXT: llvm.icmp // BAREPTR-NEXT: llvm.icmp
// BAREPTR-NEXT: llvm.cond_br %{{.*}}, ^bb2, ^bb3 // BAREPTR-NEXT: llvm.cond_br %{{.*}}, ^bb2, ^bb3
^bb1(%0: index, %1: memref<64xi32, 201>, %2: memref<64xi32, 201>): // 2 preds: ^bb0, ^bb2 ^bb1(%0: index, %1: memref<64xi32, 201>, %2: memref<64xi32, 201>): // 2 preds: ^bb0, ^bb2
%3 = arith.cmpi slt, %0, %arg1 : index %3 = arith.cmpi slt, %0, %arg1 : index
cond_br %3, ^bb2, ^bb3 cf.cond_br %3, ^bb2, ^bb3
^bb2: // pred: ^bb1 ^bb2: // pred: ^bb1
%4 = arith.addi %0, %arg2 : index %4 = arith.addi %0, %arg2 : index
br ^bb1(%4, %2, %1 : index, memref<64xi32, 201>, memref<64xi32, 201>) cf.br ^bb1(%4, %2, %1 : index, memref<64xi32, 201>, memref<64xi32, 201>)
^bb3: // pred: ^bb1 ^bb3: // pred: ^bb1
return %1, %2 : memref<64xi32, 201>, memref<64xi32, 201> return %1, %2 : memref<64xi32, 201>, memref<64xi32, 201>
} }

mlir/test/Conversion/StandardToLLVM/standard-to-llvm.mlir

Show All 12 Lines
func private @body(index) func private @body(index)
// CHECK-LABEL: func @simple_loop() { // CHECK-LABEL: func @simple_loop() {
// CHECK32-LABEL: func @simple_loop() { // CHECK32-LABEL: func @simple_loop() {
func @simple_loop() { func @simple_loop() {
^bb0: ^bb0:
// CHECK-NEXT: llvm.br ^bb1 // CHECK-NEXT: llvm.br ^bb1
// CHECK32-NEXT: llvm.br ^bb1 // CHECK32-NEXT: llvm.br ^bb1
br ^bb1 cf.br ^bb1
// CHECK-NEXT: ^bb1: // pred: ^bb0 // CHECK-NEXT: ^bb1: // pred: ^bb0
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : i64) // CHECK-NEXT: llvm.br ^bb2({{.*}} : i64)
// CHECK32-NEXT: ^bb1: // pred: ^bb0 // CHECK32-NEXT: ^bb1: // pred: ^bb0
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i32
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i32
// CHECK32-NEXT: llvm.br ^bb2({{.*}} : i32) // CHECK32-NEXT: llvm.br ^bb2({{.*}} : i32)
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c42 = arith.constant 42 : index %c42 = arith.constant 42 : index
br ^bb2(%c1 : index) cf.br ^bb2(%c1 : index)
// CHECK: ^bb2({{.*}}: i64): // 2 preds: ^bb1, ^bb3 // CHECK: ^bb2({{.*}}: i64): // 2 preds: ^bb1, ^bb3
// CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i64 // CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4 // CHECK-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4
// CHECK32: ^bb2({{.*}}: i32): // 2 preds: ^bb1, ^bb3 // CHECK32: ^bb2({{.*}}: i32): // 2 preds: ^bb1, ^bb3
// CHECK32-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i32 // CHECK32-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i32
// CHECK32-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4 // CHECK32-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4
^bb2(%0: index): // 2 preds: ^bb1, ^bb3 ^bb2(%0: index): // 2 preds: ^bb1, ^bb3
%1 = arith.cmpi slt, %0, %c42 : index %1 = arith.cmpi slt, %0, %c42 : index
cond_br %1, ^bb3, ^bb4 cf.cond_br %1, ^bb3, ^bb4
// CHECK: ^bb3: // pred: ^bb2 // CHECK: ^bb3: // pred: ^bb2
// CHECK-NEXT: llvm.call @body({{.*}}) : (i64) -> () // CHECK-NEXT: llvm.call @body({{.*}}) : (i64) -> ()
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64 // CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : i64) // CHECK-NEXT: llvm.br ^bb2({{.*}} : i64)
// CHECK32: ^bb3: // pred: ^bb2 // CHECK32: ^bb3: // pred: ^bb2
// CHECK32-NEXT: llvm.call @body({{.*}}) : (i32) -> () // CHECK32-NEXT: llvm.call @body({{.*}}) : (i32) -> ()
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i32
// CHECK32-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i32 // CHECK32-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i32
// CHECK32-NEXT: llvm.br ^bb2({{.*}} : i32) // CHECK32-NEXT: llvm.br ^bb2({{.*}} : i32)
^bb3: // pred: ^bb2 ^bb3: // pred: ^bb2
call @body(%0) : (index) -> () call @body(%0) : (index) -> ()
%c1_0 = arith.constant 1 : index %c1_0 = arith.constant 1 : index
%2 = arith.addi %0, %c1_0 : index %2 = arith.addi %0, %c1_0 : index
br ^bb2(%2 : index) cf.br ^bb2(%2 : index)
// CHECK: ^bb4: // pred: ^bb2 // CHECK: ^bb4: // pred: ^bb2
// CHECK-NEXT: llvm.return // CHECK-NEXT: llvm.return
^bb4: // pred: ^bb2 ^bb4: // pred: ^bb2
return return
} }
// CHECK-LABEL: func @simple_caller() { // CHECK-LABEL: func @simple_caller() {
Show All 37 Lines
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : i32) : i32 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : i32) : i32
// CHECK-NEXT: llvm.br ^bb1 // CHECK-NEXT: llvm.br ^bb1
// CHECK32-LABEL: func @func_args(%arg0: i32, %arg1: i32) -> i32 { // CHECK32-LABEL: func @func_args(%arg0: i32, %arg1: i32) -> i32 {
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(0 : i32) : i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(0 : i32) : i32
// CHECK32-NEXT: llvm.br ^bb1 // CHECK32-NEXT: llvm.br ^bb1
func @func_args(i32, i32) -> i32 { func @func_args(i32, i32) -> i32 {
^bb0(%arg0: i32, %arg1: i32): ^bb0(%arg0: i32, %arg1: i32):
%c0_i32 = arith.constant 0 : i32 %c0_i32 = arith.constant 0 : i32
br ^bb1 cf.br ^bb1
// CHECK-NEXT: ^bb1: // pred: ^bb0 // CHECK-NEXT: ^bb1: // pred: ^bb0
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : i64) // CHECK-NEXT: llvm.br ^bb2({{.*}} : i64)
// CHECK32-NEXT: ^bb1: // pred: ^bb0 // CHECK32-NEXT: ^bb1: // pred: ^bb0
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i32
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i32
// CHECK32-NEXT: llvm.br ^bb2({{.*}} : i32) // CHECK32-NEXT: llvm.br ^bb2({{.*}} : i32)
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c42 = arith.constant 42 : index %c42 = arith.constant 42 : index
br ^bb2(%c0 : index) cf.br ^bb2(%c0 : index)
// CHECK-NEXT: ^bb2({{.*}}: i64): // 2 preds: ^bb1, ^bb3 // CHECK-NEXT: ^bb2({{.*}}: i64): // 2 preds: ^bb1, ^bb3
// CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i64 // CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4 // CHECK-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4
// CHECK32-NEXT: ^bb2({{.*}}: i32): // 2 preds: ^bb1, ^bb3 // CHECK32-NEXT: ^bb2({{.*}}: i32): // 2 preds: ^bb1, ^bb3
// CHECK32-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i32 // CHECK32-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i32
// CHECK32-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4 // CHECK32-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4
^bb2(%0: index): // 2 preds: ^bb1, ^bb3 ^bb2(%0: index): // 2 preds: ^bb1, ^bb3
%1 = arith.cmpi slt, %0, %c42 : index %1 = arith.cmpi slt, %0, %c42 : index
cond_br %1, ^bb3, ^bb4 cf.cond_br %1, ^bb3, ^bb4
// CHECK-NEXT: ^bb3: // pred: ^bb2 // CHECK-NEXT: ^bb3: // pred: ^bb2
// CHECK-NEXT: {{.*}} = llvm.call @body_args({{.*}}) : (i64) -> i64 // CHECK-NEXT: {{.*}} = llvm.call @body_args({{.*}}) : (i64) -> i64
// CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg0) : (i64, i32) -> i32 // CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg0) : (i64, i32) -> i32
// CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (i64, i32) -> i32 // CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (i64, i32) -> i32
// CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg1) : (i64, i32) -> i32 // CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg1) : (i64, i32) -> i32
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64 // CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : i64) // CHECK-NEXT: llvm.br ^bb2({{.*}} : i64)
// CHECK32-NEXT: ^bb3: // pred: ^bb2 // CHECK32-NEXT: ^bb3: // pred: ^bb2
// CHECK32-NEXT: {{.*}} = llvm.call @body_args({{.*}}) : (i32) -> i32 // CHECK32-NEXT: {{.*}} = llvm.call @body_args({{.*}}) : (i32) -> i32
// CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg0) : (i32, i32) -> i32 // CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg0) : (i32, i32) -> i32
// CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (i32, i32) -> i32 // CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (i32, i32) -> i32
// CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg1) : (i32, i32) -> i32 // CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg1) : (i32, i32) -> i32
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i32
// CHECK32-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i32 // CHECK32-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i32
// CHECK32-NEXT: llvm.br ^bb2({{.*}} : i32) // CHECK32-NEXT: llvm.br ^bb2({{.*}} : i32)
^bb3: // pred: ^bb2 ^bb3: // pred: ^bb2
%2 = call @body_args(%0) : (index) -> index %2 = call @body_args(%0) : (index) -> index
%3 = call @other(%2, %arg0) : (index, i32) -> i32 %3 = call @other(%2, %arg0) : (index, i32) -> i32
%4 = call @other(%2, %3) : (index, i32) -> i32 %4 = call @other(%2, %3) : (index, i32) -> i32
%5 = call @other(%2, %arg1) : (index, i32) -> i32 %5 = call @other(%2, %arg1) : (index, i32) -> i32
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%6 = arith.addi %0, %c1 : index %6 = arith.addi %0, %c1 : index
br ^bb2(%6 : index) cf.br ^bb2(%6 : index)
// CHECK-NEXT: ^bb4: // pred: ^bb2 // CHECK-NEXT: ^bb4: // pred: ^bb2
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (i64, i32) -> i32 // CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (i64, i32) -> i32
// CHECK-NEXT: llvm.return {{.*}} : i32 // CHECK-NEXT: llvm.return {{.*}} : i32
// CHECK32-NEXT: ^bb4: // pred: ^bb2 // CHECK32-NEXT: ^bb4: // pred: ^bb2
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i32
// CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (i32, i32) -> i32 // CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (i32, i32) -> i32
Show All 15 Lines
// CHECK-LABEL: llvm.func @post(i64) // CHECK-LABEL: llvm.func @post(i64)
// CHECK32-LABEL: llvm.func @post(i32) // CHECK32-LABEL: llvm.func @post(i32)
func private @post(index) func private @post(index)
// CHECK-LABEL: func @imperfectly_nested_loops() { // CHECK-LABEL: func @imperfectly_nested_loops() {
// CHECK-NEXT: llvm.br ^bb1 // CHECK-NEXT: llvm.br ^bb1
func @imperfectly_nested_loops() { func @imperfectly_nested_loops() {
^bb0: ^bb0:
br ^bb1 cf.br ^bb1
// CHECK-NEXT: ^bb1: // pred: ^bb0 // CHECK-NEXT: ^bb1: // pred: ^bb0
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : i64) // CHECK-NEXT: llvm.br ^bb2({{.*}} : i64)
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c42 = arith.constant 42 : index %c42 = arith.constant 42 : index
br ^bb2(%c0 : index) cf.br ^bb2(%c0 : index)
// CHECK-NEXT: ^bb2({{.*}}: i64): // 2 preds: ^bb1, ^bb7 // CHECK-NEXT: ^bb2({{.*}}: i64): // 2 preds: ^bb1, ^bb7
// CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i64 // CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb8 // CHECK-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb8
^bb2(%0: index): // 2 preds: ^bb1, ^bb7 ^bb2(%0: index): // 2 preds: ^bb1, ^bb7
%1 = arith.cmpi slt, %0, %c42 : index %1 = arith.cmpi slt, %0, %c42 : index
cond_br %1, ^bb3, ^bb8 cf.cond_br %1, ^bb3, ^bb8
// CHECK-NEXT: ^bb3: // CHECK-NEXT: ^bb3:
// CHECK-NEXT: llvm.call @pre({{.*}}) : (i64) -> () // CHECK-NEXT: llvm.call @pre({{.*}}) : (i64) -> ()
// CHECK-NEXT: llvm.br ^bb4 // CHECK-NEXT: llvm.br ^bb4
^bb3: // pred: ^bb2 ^bb3: // pred: ^bb2
call @pre(%0) : (index) -> () call @pre(%0) : (index) -> ()
br ^bb4 cf.br ^bb4
// CHECK-NEXT: ^bb4: // pred: ^bb3 // CHECK-NEXT: ^bb4: // pred: ^bb3
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(7 : index) : i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(7 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(56 : index) : i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(56 : index) : i64
// CHECK-NEXT: llvm.br ^bb5({{.*}} : i64) // CHECK-NEXT: llvm.br ^bb5({{.*}} : i64)
^bb4: // pred: ^bb3 ^bb4: // pred: ^bb3
%c7 = arith.constant 7 : index %c7 = arith.constant 7 : index
%c56 = arith.constant 56 : index %c56 = arith.constant 56 : index
br ^bb5(%c7 : index) cf.br ^bb5(%c7 : index)
// CHECK-NEXT: ^bb5({{.*}}: i64): // 2 preds: ^bb4, ^bb6 // CHECK-NEXT: ^bb5({{.*}}: i64): // 2 preds: ^bb4, ^bb6
// CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i64 // CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.cond_br {{.*}}, ^bb6, ^bb7 // CHECK-NEXT: llvm.cond_br {{.*}}, ^bb6, ^bb7
^bb5(%2: index): // 2 preds: ^bb4, ^bb6 ^bb5(%2: index): // 2 preds: ^bb4, ^bb6
%3 = arith.cmpi slt, %2, %c56 : index %3 = arith.cmpi slt, %2, %c56 : index
cond_br %3, ^bb6, ^bb7 cf.cond_br %3, ^bb6, ^bb7
// CHECK-NEXT: ^bb6: // pred: ^bb5 // CHECK-NEXT: ^bb6: // pred: ^bb5
// CHECK-NEXT: llvm.call @body2({{.*}}, {{.*}}) : (i64, i64) -> () // CHECK-NEXT: llvm.call @body2({{.*}}, {{.*}}) : (i64, i64) -> ()
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(2 : index) : i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(2 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64 // CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.br ^bb5({{.*}} : i64) // CHECK-NEXT: llvm.br ^bb5({{.*}} : i64)
^bb6: // pred: ^bb5 ^bb6: // pred: ^bb5
call @body2(%0, %2) : (index, index) -> () call @body2(%0, %2) : (index, index) -> ()
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%4 = arith.addi %2, %c2 : index %4 = arith.addi %2, %c2 : index
br ^bb5(%4 : index) cf.br ^bb5(%4 : index)
// CHECK-NEXT: ^bb7: // pred: ^bb5 // CHECK-NEXT: ^bb7: // pred: ^bb5
// CHECK-NEXT: llvm.call @post({{.*}}) : (i64) -> () // CHECK-NEXT: llvm.call @post({{.*}}) : (i64) -> ()
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64 // CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : i64) // CHECK-NEXT: llvm.br ^bb2({{.*}} : i64)
^bb7: // pred: ^bb5 ^bb7: // pred: ^bb5
call @post(%0) : (index) -> () call @post(%0) : (index) -> ()
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%5 = arith.addi %0, %c1 : index %5 = arith.addi %0, %c1 : index
br ^bb2(%5 : index) cf.br ^bb2(%5 : index)
// CHECK-NEXT: ^bb8: // pred: ^bb2 // CHECK-NEXT: ^bb8: // pred: ^bb2
// CHECK-NEXT: llvm.return // CHECK-NEXT: llvm.return
^bb8: // pred: ^bb2 ^bb8: // pred: ^bb2
return return
} }
// CHECK-LABEL: llvm.func @mid(i64) // CHECK-LABEL: llvm.func @mid(i64)
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64 // CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : i64) // CHECK-NEXT: llvm.br ^bb2({{.*}} : i64)
// CHECK-NEXT:^bb12: // pred: ^bb2 // CHECK-NEXT:^bb12: // pred: ^bb2
// CHECK-NEXT: llvm.return // CHECK-NEXT: llvm.return
// CHECK-NEXT: } // CHECK-NEXT: }
func @more_imperfectly_nested_loops() { func @more_imperfectly_nested_loops() {
^bb0: ^bb0:
br ^bb1 cf.br ^bb1
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c42 = arith.constant 42 : index %c42 = arith.constant 42 : index
br ^bb2(%c0 : index) cf.br ^bb2(%c0 : index)
^bb2(%0: index): // 2 preds: ^bb1, ^bb11 ^bb2(%0: index): // 2 preds: ^bb1, ^bb11
%1 = arith.cmpi slt, %0, %c42 : index %1 = arith.cmpi slt, %0, %c42 : index
cond_br %1, ^bb3, ^bb12 cf.cond_br %1, ^bb3, ^bb12
^bb3: // pred: ^bb2 ^bb3: // pred: ^bb2
call @pre(%0) : (index) -> () call @pre(%0) : (index) -> ()
br ^bb4 cf.br ^bb4
^bb4: // pred: ^bb3 ^bb4: // pred: ^bb3
%c7 = arith.constant 7 : index %c7 = arith.constant 7 : index
%c56 = arith.constant 56 : index %c56 = arith.constant 56 : index
br ^bb5(%c7 : index) cf.br ^bb5(%c7 : index)
^bb5(%2: index): // 2 preds: ^bb4, ^bb6 ^bb5(%2: index): // 2 preds: ^bb4, ^bb6
%3 = arith.cmpi slt, %2, %c56 : index %3 = arith.cmpi slt, %2, %c56 : index
cond_br %3, ^bb6, ^bb7 cf.cond_br %3, ^bb6, ^bb7
^bb6: // pred: ^bb5 ^bb6: // pred: ^bb5
call @body2(%0, %2) : (index, index) -> () call @body2(%0, %2) : (index, index) -> ()
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%4 = arith.addi %2, %c2 : index %4 = arith.addi %2, %c2 : index
br ^bb5(%4 : index) cf.br ^bb5(%4 : index)
^bb7: // pred: ^bb5 ^bb7: // pred: ^bb5
call @mid(%0) : (index) -> () call @mid(%0) : (index) -> ()
br ^bb8 cf.br ^bb8
^bb8: // pred: ^bb7 ^bb8: // pred: ^bb7
%c18 = arith.constant 18 : index %c18 = arith.constant 18 : index
%c37 = arith.constant 37 : index %c37 = arith.constant 37 : index
br ^bb9(%c18 : index) cf.br ^bb9(%c18 : index)
^bb9(%5: index): // 2 preds: ^bb8, ^bb10 ^bb9(%5: index): // 2 preds: ^bb8, ^bb10
%6 = arith.cmpi slt, %5, %c37 : index %6 = arith.cmpi slt, %5, %c37 : index
cond_br %6, ^bb10, ^bb11 cf.cond_br %6, ^bb10, ^bb11
^bb10: // pred: ^bb9 ^bb10: // pred: ^bb9
call @body3(%0, %5) : (index, index) -> () call @body3(%0, %5) : (index, index) -> ()
%c3 = arith.constant 3 : index %c3 = arith.constant 3 : index
%7 = arith.addi %5, %c3 : index %7 = arith.addi %5, %c3 : index
br ^bb9(%7 : index) cf.br ^bb9(%7 : index)
^bb11: // pred: ^bb9 ^bb11: // pred: ^bb9
call @post(%0) : (index) -> () call @post(%0) : (index) -> ()
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%8 = arith.addi %0, %c1 : index %8 = arith.addi %0, %c1 : index
br ^bb2(%8 : index) cf.br ^bb2(%8 : index)
^bb12: // pred: ^bb2 ^bb12: // pred: ^bb2
return return
} }
// CHECK-LABEL: llvm.func @get_i64() -> i64 // CHECK-LABEL: llvm.func @get_i64() -> i64
func private @get_i64() -> (i64) func private @get_i64() -> (i64)
// CHECK-LABEL: llvm.func @get_f32() -> f32 // CHECK-LABEL: llvm.func @get_f32() -> f32
func private @get_f32() -> (f32) func private @get_f32() -> (f32)
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines// CHECK: {{.*}} = llvm.fadd {{.*}}, {{.*}} : f32
return return
} }
// CHECK-LABEL: @dfs_block_order // CHECK-LABEL: @dfs_block_order
func @dfs_block_order(%arg0: i32) -> (i32) { func @dfs_block_order(%arg0: i32) -> (i32) {
// CHECK-NEXT: %[[CST:.*]] = llvm.mlir.constant(42 : i32) : i32 // CHECK-NEXT: %[[CST:.*]] = llvm.mlir.constant(42 : i32) : i32
%0 = arith.constant 42 : i32 %0 = arith.constant 42 : i32
// CHECK-NEXT: llvm.br ^bb2 // CHECK-NEXT: llvm.br ^bb2
br ^bb2 cf.br ^bb2
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
// CHECK-NEXT: %[[ADD:.*]] = llvm.add %arg0, %[[CST]] : i32 // CHECK-NEXT: %[[ADD:.*]] = llvm.add %arg0, %[[CST]] : i32
// CHECK-NEXT: llvm.return %[[ADD]] : i32 // CHECK-NEXT: llvm.return %[[ADD]] : i32
^bb1: ^bb1:
%2 = arith.addi %arg0, %0 : i32 %2 = arith.addi %arg0, %0 : i32
return %2 : i32 return %2 : i32
// CHECK-NEXT: ^bb2: // CHECK-NEXT: ^bb2:
^bb2: ^bb2:
// CHECK-NEXT: llvm.br ^bb1 // CHECK-NEXT: llvm.br ^bb1
br ^bb1 cf.br ^bb1
} }
// ----- // -----
// CHECK-LABEL: func @ceilf( // CHECK-LABEL: func @ceilf(
// CHECK-SAME: f32 // CHECK-SAME: f32
func @ceilf(%arg0 : f32) { func @ceilf(%arg0 : f32) {
// CHECK: "llvm.intr.ceil"(%arg0) : (f32) -> f32 // CHECK: "llvm.intr.ceil"(%arg0) : (f32) -> f32
%0 = math.ceil %arg0 : f32 %0 = math.ceil %arg0 : f32
std.return std.return
} }
// ----- // -----
// CHECK-LABEL: func @floorf( // CHECK-LABEL: func @floorf(
// CHECK-SAME: f32 // CHECK-SAME: f32
func @floorf(%arg0 : f32) { func @floorf(%arg0 : f32) {
// CHECK: "llvm.intr.floor"(%arg0) : (f32) -> f32 // CHECK: "llvm.intr.floor"(%arg0) : (f32) -> f32
%0 = math.floor %arg0 : f32 %0 = math.floor %arg0 : f32
std.return std.return
} }
// ----- // -----
// Lowers `assert` to a function call to `abort` if the assertion is violated. // Lowers `cf.assert` to a function call to `abort` if the assertion is violated.
// CHECK: llvm.func @abort() // CHECK: llvm.func @abort()
// CHECK-LABEL: @assert_test_function // CHECK-LABEL: @assert_test_function
// CHECK-SAME: (%[[ARG:.*]]: i1) // CHECK-SAME: (%[[ARG:.*]]: i1)
func @assert_test_function(%arg : i1) { func @assert_test_function(%arg : i1) {
// CHECK: llvm.cond_br %[[ARG]], ^[[CONTINUATION_BLOCK:.*]], ^[[FAILURE_BLOCK:.*]] // CHECK: llvm.cond_br %[[ARG]], ^[[CONTINUATION_BLOCK:.*]], ^[[FAILURE_BLOCK:.*]]
// CHECK: ^[[CONTINUATION_BLOCK]]: // CHECK: ^[[CONTINUATION_BLOCK]]:
// CHECK: llvm.return // CHECK: llvm.return
// CHECK: ^[[FAILURE_BLOCK]]: // CHECK: ^[[FAILURE_BLOCK]]:
// CHECK: llvm.call @abort() : () -> () // CHECK: llvm.call @abort() : () -> ()
// CHECK: llvm.unreachable // CHECK: llvm.unreachable
assert %arg, "Computer says no" cf.assert %arg, "Computer says no"
return return
} }
// ----- // -----
// This should not trigger an assertion by creating an LLVM::CallOp with a // This should not trigger an assertion by creating an LLVM::CallOp with a
// nullptr result type. // nullptr result type.
Show All 17 Linesfunc @fmaf(%arg0: f32, %arg1: vector<4xf32>) {
%1 = math.fma %arg1, %arg1, %arg1 : vector<4xf32> %1 = math.fma %arg1, %arg1, %arg1 : vector<4xf32>
std.return std.return
} }
// ----- // -----
// CHECK-LABEL: func @switchi8( // CHECK-LABEL: func @switchi8(
func @switchi8(%arg0 : i8) -> i32 { func @switchi8(%arg0 : i8) -> i32 {
switch %arg0 : i8, [ cf.switch %arg0 : i8, [
default: ^bb1, default: ^bb1,
42: ^bb1, 42: ^bb1,
43: ^bb3 43: ^bb3
] ]
^bb1: ^bb1:
%c_1 = arith.constant 1 : i32 %c_1 = arith.constant 1 : i32
std.return %c_1 : i32 std.return %c_1 : i32
^bb3: ^bb3:
%c_42 = arith.constant 42 : i32 %c_42 = arith.constant 42 : i32
Show All 13 Lines

mlir/test/Conversion/StandardToSPIRV/std-ops-to-spirv.mlir

Show First 20 Lines • Show All 894 Lines • ▼ Show 20 Linesfunc @tensor_extract_constant(%a : index, %b: index, %c: index) -> i32 {
// CHECK: %[[MUL2:.+]] = spv.IMul %[[C1]], %[[C]] : i32 // CHECK: %[[MUL2:.+]] = spv.IMul %[[C1]], %[[C]] : i32
// CHECK: %[[ADD2:.+]] = spv.IAdd %[[ADD1]], %[[MUL2]] : i32 // CHECK: %[[ADD2:.+]] = spv.IAdd %[[ADD1]], %[[MUL2]] : i32
// CHECK: %[[AC:.+]] = spv.AccessChain %[[VAR]][%[[ADD2]]] // CHECK: %[[AC:.+]] = spv.AccessChain %[[VAR]][%[[ADD2]]]
// CHECK: %[[VAL:.+]] = spv.Load "Function" %[[AC]] : i32 // CHECK: %[[VAL:.+]] = spv.Load "Function" %[[AC]] : i32
%extract = tensor.extract %cst[%a, %b, %c] : tensor<2x2x3xi32> %extract = tensor.extract %cst[%a, %b, %c] : tensor<2x2x3xi32>
// CHECK: spv.ReturnValue %[[VAL]] // CHECK: spv.ReturnValue %[[VAL]]
return %extract : i32 return %extract : i32
} }
// -----
//===----------------------------------------------------------------------===//
// std.br, std.cond_br
//===----------------------------------------------------------------------===//
module attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.0, [], []>, {}>
} {
// CHECK-LABEL: func @simple_loop
func @simple_loop(index, index, index) {
^bb0(%begin : index, %end : index, %step : index):
// CHECK-NEXT: spv.Branch ^bb1
br ^bb1
// CHECK-NEXT: ^bb1: // pred: ^bb0
// CHECK-NEXT: spv.Branch ^bb2({{.*}} : i32)
^bb1: // pred: ^bb0
br ^bb2(%begin : index)
// CHECK: ^bb2({{.*}}: i32): // 2 preds: ^bb1, ^bb3
// CHECK-NEXT: {{.*}} = spv.SLessThan {{.*}}, {{.*}} : i32
// CHECK-NEXT: spv.BranchConditional {{.*}}, ^bb3, ^bb4
^bb2(%0: index): // 2 preds: ^bb1, ^bb3
%1 = arith.cmpi slt, %0, %end : index
cond_br %1, ^bb3, ^bb4
// CHECK: ^bb3: // pred: ^bb2
// CHECK-NEXT: {{.*}} = spv.IAdd {{.*}}, {{.*}} : i32
// CHECK-NEXT: spv.Branch ^bb2({{.*}} : i32)
^bb3: // pred: ^bb2
%2 = arith.addi %0, %step : index
br ^bb2(%2 : index)
// CHECK: ^bb4: // pred: ^bb2
^bb4: // pred: ^bb2
return
}
}

mlir/test/Dialect/Affine/invalid.mlir

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
} }
// ----- // -----
func @affine_load_invalid_dim(%M : memref<10xi32>) { func @affine_load_invalid_dim(%M : memref<10xi32>) {
"unknown"() ({ "unknown"() ({
^bb0(%arg: index): ^bb0(%arg: index):
affine.load %M[%arg] : memref<10xi32> affine.load %M[%arg] : memref<10xi32>
// expected-error@-1 {{index must be a dimension or symbol identifier}} // expected-error@-1 {{index must be a dimension or symbol identifier}}
br ^bb1 cf.br ^bb1
^bb1: ^bb1:
br ^bb1 cf.br ^bb1
}) : () -> () }) : () -> ()
return return
} }
// ----- // -----
#map0 = affine_map<(d0)[s0] -> (d0 + s0)> #map0 = affine_map<(d0)[s0] -> (d0 + s0)>
▲ Show 20 Lines • Show All 313 Lines • Show Last 20 Lines

mlir/test/Dialect/Async/async-runtime-ref-counting.mlir

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linesfunc @token_value_to_func() {
call @take_token(%0): (!async.token) -> () call @take_token(%0): (!async.token) -> ()
// CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64} // CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64}
return return
} }
// CHECK-LABEL: @token_arg_cond_br_await_with_fallthough // CHECK-LABEL: @token_arg_cond_br_await_with_fallthough
// CHECK: %[[TOKEN:.*]]: !async.token // CHECK: %[[TOKEN:.*]]: !async.token
func @token_arg_cond_br_await_with_fallthough(%arg0: !async.token, %arg1: i1) { func @token_arg_cond_br_await_with_fallthough(%arg0: !async.token, %arg1: i1) {
// CHECK: cond_br // CHECK: cf.cond_br
// CHECK-SAME: ^[[BB1:.*]], ^[[BB2:.*]] // CHECK-SAME: ^[[BB1:.*]], ^[[BB2:.*]]
cond_br %arg1, ^bb1, ^bb2 cf.cond_br %arg1, ^bb1, ^bb2
^bb1: ^bb1:
// CHECK: ^[[BB1]]: // CHECK: ^[[BB1]]:
// CHECK: br ^[[BB2]] // CHECK: cf.br ^[[BB2]]
br ^bb2 cf.br ^bb2
^bb2: ^bb2:
// CHECK: ^[[BB2]]: // CHECK: ^[[BB2]]:
// CHECK: async.runtime.await %[[TOKEN]] // CHECK: async.runtime.await %[[TOKEN]]
// CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64} // CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64}
async.runtime.await %arg0 : !async.token async.runtime.await %arg0 : !async.token
return return
} }
Show All 11 Lines
func @token_coro_return() -> !async.token { func @token_coro_return() -> !async.token {
%token = async.runtime.create : !async.token %token = async.runtime.create : !async.token
%id = async.coro.id %id = async.coro.id
%hdl = async.coro.begin %id %hdl = async.coro.begin %id
%saved = async.coro.save %hdl %saved = async.coro.save %hdl
async.runtime.resume %hdl async.runtime.resume %hdl
async.coro.suspend %saved, ^suspend, ^resume, ^cleanup async.coro.suspend %saved, ^suspend, ^resume, ^cleanup
^resume: ^resume:
br ^cleanup cf.br ^cleanup
^cleanup: ^cleanup:
async.coro.free %id, %hdl async.coro.free %id, %hdl
br ^suspend cf.br ^suspend
^suspend: ^suspend:
async.coro.end %hdl async.coro.end %hdl
return %token : !async.token return %token : !async.token
} }
// CHECK-LABEL: @token_coro_await_and_resume // CHECK-LABEL: @token_coro_await_and_resume
// CHECK: %[[TOKEN:.*]]: !async.token // CHECK: %[[TOKEN:.*]]: !async.token
func @token_coro_await_and_resume(%arg0: !async.token) -> !async.token { func @token_coro_await_and_resume(%arg0: !async.token) -> !async.token {
%token = async.runtime.create : !async.token %token = async.runtime.create : !async.token
%id = async.coro.id %id = async.coro.id
%hdl = async.coro.begin %id %hdl = async.coro.begin %id
%saved = async.coro.save %hdl %saved = async.coro.save %hdl
// CHECK: async.runtime.await_and_resume %[[TOKEN]] // CHECK: async.runtime.await_and_resume %[[TOKEN]]
async.runtime.await_and_resume %arg0, %hdl : !async.token async.runtime.await_and_resume %arg0, %hdl : !async.token
// CHECK-NEXT: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64} // CHECK-NEXT: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64}
async.coro.suspend %saved, ^suspend, ^resume, ^cleanup async.coro.suspend %saved, ^suspend, ^resume, ^cleanup
^resume: ^resume:
br ^cleanup cf.br ^cleanup
^cleanup: ^cleanup:
async.coro.free %id, %hdl async.coro.free %id, %hdl
br ^suspend cf.br ^suspend
^suspend: ^suspend:
async.coro.end %hdl async.coro.end %hdl
return %token : !async.token return %token : !async.token
} }
// CHECK-LABEL: @value_coro_await_and_resume // CHECK-LABEL: @value_coro_await_and_resume
// CHECK: %[[VALUE:.*]]: !async.value<f32> // CHECK: %[[VALUE:.*]]: !async.value<f32>
func @value_coro_await_and_resume(%arg0: !async.value<f32>) -> !async.token { func @value_coro_await_and_resume(%arg0: !async.value<f32>) -> !async.token {
%token = async.runtime.create : !async.token %token = async.runtime.create : !async.token
%id = async.coro.id %id = async.coro.id
%hdl = async.coro.begin %id %hdl = async.coro.begin %id
%saved = async.coro.save %hdl %saved = async.coro.save %hdl
// CHECK: async.runtime.await_and_resume %[[VALUE]] // CHECK: async.runtime.await_and_resume %[[VALUE]]
async.runtime.await_and_resume %arg0, %hdl : !async.value<f32> async.runtime.await_and_resume %arg0, %hdl : !async.value<f32>
// CHECK: async.coro.suspend // CHECK: async.coro.suspend
// CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME:.*]], ^[[CLEANUP:.*]] // CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME:.*]], ^[[CLEANUP:.*]]
async.coro.suspend %saved, ^suspend, ^resume, ^cleanup async.coro.suspend %saved, ^suspend, ^resume, ^cleanup
^resume: ^resume:
// CHECK: ^[[RESUME]]: // CHECK: ^[[RESUME]]:
// CHECK: %[[LOADED:.*]] = async.runtime.load %[[VALUE]] // CHECK: %[[LOADED:.*]] = async.runtime.load %[[VALUE]]
// CHECK: async.runtime.drop_ref %[[VALUE]] {count = 1 : i64} // CHECK: async.runtime.drop_ref %[[VALUE]] {count = 1 : i64}
%0 = async.runtime.load %arg0 : !async.value<f32> %0 = async.runtime.load %arg0 : !async.value<f32>
// CHECK: arith.addf %[[LOADED]], %[[LOADED]] // CHECK: arith.addf %[[LOADED]], %[[LOADED]]
%1 = arith.addf %0, %0 : f32 %1 = arith.addf %0, %0 : f32
br ^cleanup cf.br ^cleanup
^cleanup: ^cleanup:
async.coro.free %id, %hdl async.coro.free %id, %hdl
br ^suspend cf.br ^suspend
^suspend: ^suspend:
async.coro.end %hdl async.coro.end %hdl
return %token : !async.token return %token : !async.token
} }
// CHECK-LABEL: @outlined_async_execute // CHECK-LABEL: @outlined_async_execute
// CHECK: %[[TOKEN:.*]]: !async.token // CHECK: %[[TOKEN:.*]]: !async.token
func private @outlined_async_execute(%arg0: !async.token) -> !async.token { func private @outlined_async_execute(%arg0: !async.token) -> !async.token {
Show All 10 Lines^resume:
async.runtime.await_and_resume %arg0, %2 : !async.token async.runtime.await_and_resume %arg0, %2 : !async.token
// CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64} // CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64}
// CHECK: async.coro.suspend // CHECK: async.coro.suspend
async.coro.suspend %4, ^suspend, ^resume_1, ^cleanup async.coro.suspend %4, ^suspend, ^resume_1, ^cleanup
^resume_1: ^resume_1:
// CHECK: ^[[RESUME_1:.*]]: // CHECK: ^[[RESUME_1:.*]]:
// CHECK: async.runtime.set_available // CHECK: async.runtime.set_available
async.runtime.set_available %0 : !async.token async.runtime.set_available %0 : !async.token
br ^cleanup cf.br ^cleanup
^cleanup: ^cleanup:
// CHECK: ^[[CLEANUP:.*]]: // CHECK: ^[[CLEANUP:.*]]:
// CHECK: async.coro.free // CHECK: async.coro.free
async.coro.free %1, %2 async.coro.free %1, %2
br ^suspend cf.br ^suspend
^suspend: ^suspend:
// CHECK: ^[[SUSPEND:.*]]: // CHECK: ^[[SUSPEND:.*]]:
// CHECK: async.coro.end // CHECK: async.coro.end
async.coro.end %2 async.coro.end %2
return %0 : !async.token return %0 : !async.token
} }
// CHECK-LABEL: @token_await_inside_nested_region // CHECK-LABEL: @token_await_inside_nested_region
Show All 9 Linesfunc @token_await_inside_nested_region(%arg0: i1) {
// CHECK: } // CHECK: }
// CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64} // CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64}
// CHECK: return // CHECK: return
return return
} }
// CHECK-LABEL: @token_defined_in_the_loop // CHECK-LABEL: @token_defined_in_the_loop
func @token_defined_in_the_loop() { func @token_defined_in_the_loop() {
br ^bb1 cf.br ^bb1
^bb1: ^bb1:
// CHECK: ^[[BB1:.*]]: // CHECK: ^[[BB1:.*]]:
// CHECK: %[[TOKEN:.*]] = call @token() // CHECK: %[[TOKEN:.*]] = call @token()
%token = call @token() : () -> !async.token %token = call @token() : () -> !async.token
// CHECK: async.runtime.await %[[TOKEN]] // CHECK: async.runtime.await %[[TOKEN]]
// CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64} // CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64}
async.runtime.await %token : !async.token async.runtime.await %token : !async.token
%0 = call @cond(): () -> (i1) %0 = call @cond(): () -> (i1)
cond_br %0, ^bb1, ^bb2 cf.cond_br %0, ^bb1, ^bb2
^bb2: ^bb2:
// CHECK: ^[[BB2:.*]]: // CHECK: ^[[BB2:.*]]:
// CHECK: return // CHECK: return
return return
} }
// CHECK-LABEL: @divergent_liveness_one_token // CHECK-LABEL: @divergent_liveness_one_token
func @divergent_liveness_one_token(%arg0 : i1) { func @divergent_liveness_one_token(%arg0 : i1) {
// CHECK: %[[TOKEN:.*]] = call @token() // CHECK: %[[TOKEN:.*]] = call @token()
%token = call @token() : () -> !async.token %token = call @token() : () -> !async.token
// CHECK: cond_br %arg0, ^[[LIVE_IN:.*]], ^[[REF_COUNTING:.*]] // CHECK: cf.cond_br %arg0, ^[[LIVE_IN:.*]], ^[[REF_COUNTING:.*]]
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
// CHECK: ^[[LIVE_IN]]: // CHECK: ^[[LIVE_IN]]:
// CHECK: async.runtime.await %[[TOKEN]] // CHECK: async.runtime.await %[[TOKEN]]
// CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64} // CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64}
// CHECK: br ^[[RETURN:.*]] // CHECK: cf.br ^[[RETURN:.*]]
async.runtime.await %token : !async.token async.runtime.await %token : !async.token
br ^bb2 cf.br ^bb2
// CHECK: ^[[REF_COUNTING:.*]]: // CHECK: ^[[REF_COUNTING:.*]]:
// CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64} // CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64}
// CHECK: br ^[[RETURN:.*]] // CHECK: cf.br ^[[RETURN:.*]]
^bb2: ^bb2:
// CHECK: ^[[RETURN]]: // CHECK: ^[[RETURN]]:
// CHECK: return // CHECK: return
return return
} }
// CHECK-LABEL: @divergent_liveness_unique_predecessor // CHECK-LABEL: @divergent_liveness_unique_predecessor
func @divergent_liveness_unique_predecessor(%arg0 : i1) { func @divergent_liveness_unique_predecessor(%arg0 : i1) {
// CHECK: %[[TOKEN:.*]] = call @token() // CHECK: %[[TOKEN:.*]] = call @token()
%token = call @token() : () -> !async.token %token = call @token() : () -> !async.token
// CHECK: cond_br %arg0, ^[[LIVE_IN:.*]], ^[[NO_LIVE_IN:.*]] // CHECK: cf.cond_br %arg0, ^[[LIVE_IN:.*]], ^[[NO_LIVE_IN:.*]]
cond_br %arg0, ^bb2, ^bb1 cf.cond_br %arg0, ^bb2, ^bb1
^bb1: ^bb1:
// CHECK: ^[[NO_LIVE_IN]]: // CHECK: ^[[NO_LIVE_IN]]:
// CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64} // CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64}
// CHECK: br ^[[RETURN:.*]] // CHECK: cf.br ^[[RETURN:.*]]
br ^bb3 cf.br ^bb3
^bb2: ^bb2:
// CHECK: ^[[LIVE_IN]]: // CHECK: ^[[LIVE_IN]]:
// CHECK: async.runtime.await %[[TOKEN]] // CHECK: async.runtime.await %[[TOKEN]]
// CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64} // CHECK: async.runtime.drop_ref %[[TOKEN]] {count = 1 : i64}
// CHECK: br ^[[RETURN]] // CHECK: cf.br ^[[RETURN]]
async.runtime.await %token : !async.token async.runtime.await %token : !async.token
br ^bb3 cf.br ^bb3
^bb3: ^bb3:
// CHECK: ^[[RETURN]]: // CHECK: ^[[RETURN]]:
// CHECK: return // CHECK: return
return return
} }
// CHECK-LABEL: @divergent_liveness_two_tokens // CHECK-LABEL: @divergent_liveness_two_tokens
func @divergent_liveness_two_tokens(%arg0 : i1) { func @divergent_liveness_two_tokens(%arg0 : i1) {
// CHECK: %[[TOKEN0:.*]] = call @token() // CHECK: %[[TOKEN0:.*]] = call @token()
// CHECK: %[[TOKEN1:.*]] = call @token() // CHECK: %[[TOKEN1:.*]] = call @token()
%token0 = call @token() : () -> !async.token %token0 = call @token() : () -> !async.token
%token1 = call @token() : () -> !async.token %token1 = call @token() : () -> !async.token
// CHECK: cond_br %arg0, ^[[AWAIT0:.*]], ^[[AWAIT1:.*]] // CHECK: cf.cond_br %arg0, ^[[AWAIT0:.*]], ^[[AWAIT1:.*]]
cond_br %arg0, ^await0, ^await1 cf.cond_br %arg0, ^await0, ^await1
^await0: ^await0:
// CHECK: ^[[AWAIT0]]: // CHECK: ^[[AWAIT0]]:
// CHECK: async.runtime.drop_ref %[[TOKEN1]] {count = 1 : i64} // CHECK: async.runtime.drop_ref %[[TOKEN1]] {count = 1 : i64}
// CHECK: async.runtime.await %[[TOKEN0]] // CHECK: async.runtime.await %[[TOKEN0]]
// CHECK: async.runtime.drop_ref %[[TOKEN0]] {count = 1 : i64} // CHECK: async.runtime.drop_ref %[[TOKEN0]] {count = 1 : i64}
// CHECK: br ^[[RETURN:.*]] // CHECK: cf.br ^[[RETURN:.*]]
async.runtime.await %token0 : !async.token async.runtime.await %token0 : !async.token
br ^ret cf.br ^ret
^await1: ^await1:
// CHECK: ^[[AWAIT1]]: // CHECK: ^[[AWAIT1]]:
// CHECK: async.runtime.drop_ref %[[TOKEN0]] {count = 1 : i64} // CHECK: async.runtime.drop_ref %[[TOKEN0]] {count = 1 : i64}
// CHECK: async.runtime.await %[[TOKEN1]] // CHECK: async.runtime.await %[[TOKEN1]]
// CHECK: async.runtime.drop_ref %[[TOKEN1]] {count = 1 : i64} // CHECK: async.runtime.drop_ref %[[TOKEN1]] {count = 1 : i64}
// CHECK: br ^[[RETURN]] // CHECK: cf.br ^[[RETURN]]
async.runtime.await %token1 : !async.token async.runtime.await %token1 : !async.token
br ^ret cf.br ^ret
^ret: ^ret:
// CHECK: ^[[RETURN]]: // CHECK: ^[[RETURN]]:
// CHECK: return // CHECK: return
return return
} }

mlir/test/Dialect/Async/async-to-async-runtime-eliminate-blocking.mlir

// RUN: mlir-opt %s -split-input-file \ // RUN: mlir-opt %s -split-input-file \
// RUN: -async-to-async-runtime="eliminate-blocking-await-ops=true" \ // RUN: -async-to-async-runtime="eliminate-blocking-await-ops=true" \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// CHECK-LABEL: func @simple_callee // CHECK-LABEL: func @simple_callee
// CHECK-SAME: (%[[ARG:.*]]: f32) // CHECK-SAME: (%[[ARG:.*]]: f32)
// CHECK-SAME: -> (!async.token, !async.value<f32> {builtin.foo = "bar"}) // CHECK-SAME: -> (!async.token, !async.value<f32> {builtin.foo = "bar"})
func @simple_callee(%arg0: f32) -> (f32 {builtin.foo = "bar"}) { func @simple_callee(%arg0: f32) -> (f32 {builtin.foo = "bar"}) {
// CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token // CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token
// CHECK: %[[RETURNED_STORAGE:.*]] = async.runtime.create : !async.value<f32> // CHECK: %[[RETURNED_STORAGE:.*]] = async.runtime.create : !async.value<f32>
// CHECK: %[[ID:.*]] = async.coro.id // CHECK: %[[ID:.*]] = async.coro.id
// CHECK: %[[HDL:.*]] = async.coro.begin %[[ID]] // CHECK: %[[HDL:.*]] = async.coro.begin %[[ID]]
// CHECK: br ^[[ORIGINAL_ENTRY:.*]] // CHECK: cf.br ^[[ORIGINAL_ENTRY:.*]]
// CHECK ^[[ORIGINAL_ENTRY]]: // CHECK ^[[ORIGINAL_ENTRY]]:
// CHECK: %[[VAL:.*]] = arith.addf %[[ARG]], %[[ARG]] : f32 // CHECK: %[[VAL:.*]] = arith.addf %[[ARG]], %[[ARG]] : f32
%0 = arith.addf %arg0, %arg0 : f32 %0 = arith.addf %arg0, %arg0 : f32
// CHECK: %[[VAL_STORAGE:.*]] = async.runtime.create : !async.value<f32> // CHECK: %[[VAL_STORAGE:.*]] = async.runtime.create : !async.value<f32>
%1 = async.runtime.create: !async.value<f32> %1 = async.runtime.create: !async.value<f32>
// CHECK: async.runtime.store %[[VAL]], %[[VAL_STORAGE]] : <f32> // CHECK: async.runtime.store %[[VAL]], %[[VAL_STORAGE]] : <f32>
async.runtime.store %0, %1: !async.value<f32> async.runtime.store %0, %1: !async.value<f32>
// CHECK: async.runtime.set_available %[[VAL_STORAGE]] : !async.value<f32> // CHECK: async.runtime.set_available %[[VAL_STORAGE]] : !async.value<f32>
async.runtime.set_available %1: !async.value<f32> async.runtime.set_available %1: !async.value<f32>
// CHECK: %[[SAVED:.*]] = async.coro.save %[[HDL]] // CHECK: %[[SAVED:.*]] = async.coro.save %[[HDL]]
// CHECK: async.runtime.await_and_resume %[[VAL_STORAGE]], %[[HDL]] // CHECK: async.runtime.await_and_resume %[[VAL_STORAGE]], %[[HDL]]
// CHECK: async.coro.suspend %[[SAVED]] // CHECK: async.coro.suspend %[[SAVED]]
// CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME:.*]], ^[[CLEANUP:.*]] // CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME:.*]], ^[[CLEANUP:.*]]
%2 = async.await %1 : !async.value<f32> %2 = async.await %1 : !async.value<f32>
// CHECK: ^[[RESUME]]: // CHECK: ^[[RESUME]]:
// CHECK: %[[IS_ERROR:.*]] = async.runtime.is_error %[[VAL_STORAGE]] : !async.value<f32> // CHECK: %[[IS_ERROR:.*]] = async.runtime.is_error %[[VAL_STORAGE]] : !async.value<f32>
// CHECK: cond_br %[[IS_ERROR]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_OK:.*]] // CHECK: cf.cond_br %[[IS_ERROR]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_OK:.*]]
// CHECK: ^[[BRANCH_OK]]: // CHECK: ^[[BRANCH_OK]]:
// CHECK: %[[LOADED:.*]] = async.runtime.load %[[VAL_STORAGE]] : <f32> // CHECK: %[[LOADED:.*]] = async.runtime.load %[[VAL_STORAGE]] : <f32>
// CHECK: %[[RETURNED:.*]] = arith.mulf %[[ARG]], %[[LOADED]] : f32 // CHECK: %[[RETURNED:.*]] = arith.mulf %[[ARG]], %[[LOADED]] : f32
// CHECK: async.runtime.store %[[RETURNED]], %[[RETURNED_STORAGE]] : <f32> // CHECK: async.runtime.store %[[RETURNED]], %[[RETURNED_STORAGE]] : <f32>
// CHECK: async.runtime.set_available %[[RETURNED_STORAGE]] // CHECK: async.runtime.set_available %[[RETURNED_STORAGE]]
// CHECK: async.runtime.set_available %[[TOKEN]] // CHECK: async.runtime.set_available %[[TOKEN]]
// CHECK: br ^[[CLEANUP]] // CHECK: cf.br ^[[CLEANUP]]
%3 = arith.mulf %arg0, %2 : f32 %3 = arith.mulf %arg0, %2 : f32
return %3: f32 return %3: f32
// CHECK: ^[[BRANCH_ERROR]]: // CHECK: ^[[BRANCH_ERROR]]:
// CHECK: async.runtime.set_error %[[TOKEN]] // CHECK: async.runtime.set_error %[[TOKEN]]
// CHECK: async.runtime.set_error %[[RETURNED_STORAGE]] // CHECK: async.runtime.set_error %[[RETURNED_STORAGE]]
// CHECK: br ^[[CLEANUP]] // CHECK: cf.br ^[[CLEANUP]]
// CHECK: ^[[CLEANUP]]: // CHECK: ^[[CLEANUP]]:
// CHECK: async.coro.free %[[ID]], %[[HDL]] // CHECK: async.coro.free %[[ID]], %[[HDL]]
// CHECK: br ^[[SUSPEND]] // CHECK: cf.br ^[[SUSPEND]]
// CHECK: ^[[SUSPEND]]: // CHECK: ^[[SUSPEND]]:
// CHECK: async.coro.end %[[HDL]] // CHECK: async.coro.end %[[HDL]]
// CHECK: return %[[TOKEN]], %[[RETURNED_STORAGE]] : !async.token, !async.value<f32> // CHECK: return %[[TOKEN]], %[[RETURNED_STORAGE]] : !async.token, !async.value<f32>
} }
// CHECK-LABEL: func @simple_caller() // CHECK-LABEL: func @simple_caller()
// CHECK-SAME: -> (!async.token, !async.value<f32>) // CHECK-SAME: -> (!async.token, !async.value<f32>)
func @simple_caller() -> f32 { func @simple_caller() -> f32 {
// CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token // CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token
// CHECK: %[[RETURNED_STORAGE:.*]] = async.runtime.create : !async.value<f32> // CHECK: %[[RETURNED_STORAGE:.*]] = async.runtime.create : !async.value<f32>
// CHECK: %[[ID:.*]] = async.coro.id // CHECK: %[[ID:.*]] = async.coro.id
// CHECK: %[[HDL:.*]] = async.coro.begin %[[ID]] // CHECK: %[[HDL:.*]] = async.coro.begin %[[ID]]
// CHECK: br ^[[ORIGINAL_ENTRY:.*]] // CHECK: cf.br ^[[ORIGINAL_ENTRY:.*]]
// CHECK ^[[ORIGINAL_ENTRY]]: // CHECK ^[[ORIGINAL_ENTRY]]:
// CHECK: %[[CONSTANT:.*]] = arith.constant // CHECK: %[[CONSTANT:.*]] = arith.constant
%c = arith.constant 1.0 : f32 %c = arith.constant 1.0 : f32
// CHECK: %[[RETURNED_TO_CALLER:.*]]:2 = call @simple_callee(%[[CONSTANT]]) : (f32) -> (!async.token, !async.value<f32>) // CHECK: %[[RETURNED_TO_CALLER:.*]]:2 = call @simple_callee(%[[CONSTANT]]) : (f32) -> (!async.token, !async.value<f32>)
// CHECK: %[[SAVED:.*]] = async.coro.save %[[HDL]] // CHECK: %[[SAVED:.*]] = async.coro.save %[[HDL]]
// CHECK: async.runtime.await_and_resume %[[RETURNED_TO_CALLER]]#0, %[[HDL]] // CHECK: async.runtime.await_and_resume %[[RETURNED_TO_CALLER]]#0, %[[HDL]]
// CHECK: async.coro.suspend %[[SAVED]] // CHECK: async.coro.suspend %[[SAVED]]
// CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME:.*]], ^[[CLEANUP:.*]] // CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME:.*]], ^[[CLEANUP:.*]]
%r = call @simple_callee(%c): (f32) -> f32 %r = call @simple_callee(%c): (f32) -> f32
// CHECK: ^[[RESUME]]: // CHECK: ^[[RESUME]]:
// CHECK: %[[IS_TOKEN_ERROR:.*]] = async.runtime.is_error %[[RETURNED_TO_CALLER]]#0 : !async.token // CHECK: %[[IS_TOKEN_ERROR:.*]] = async.runtime.is_error %[[RETURNED_TO_CALLER]]#0 : !async.token
// CHECK: cond_br %[[IS_TOKEN_ERROR]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_TOKEN_OK:.*]] // CHECK: cf.cond_br %[[IS_TOKEN_ERROR]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_TOKEN_OK:.*]]
// CHECK: ^[[BRANCH_TOKEN_OK]]: // CHECK: ^[[BRANCH_TOKEN_OK]]:
// CHECK: %[[IS_VALUE_ERROR:.*]] = async.runtime.is_error %[[RETURNED_TO_CALLER]]#1 : !async.value<f32> // CHECK: %[[IS_VALUE_ERROR:.*]] = async.runtime.is_error %[[RETURNED_TO_CALLER]]#1 : !async.value<f32>
// CHECK: cond_br %[[IS_VALUE_ERROR]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_VALUE_OK:.*]] // CHECK: cf.cond_br %[[IS_VALUE_ERROR]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_VALUE_OK:.*]]
// CHECK: ^[[BRANCH_VALUE_OK]]: // CHECK: ^[[BRANCH_VALUE_OK]]:
// CHECK: %[[LOADED:.*]] = async.runtime.load %[[RETURNED_TO_CALLER]]#1 : <f32> // CHECK: %[[LOADED:.*]] = async.runtime.load %[[RETURNED_TO_CALLER]]#1 : <f32>
// CHECK: async.runtime.store %[[LOADED]], %[[RETURNED_STORAGE]] : <f32> // CHECK: async.runtime.store %[[LOADED]], %[[RETURNED_STORAGE]] : <f32>
// CHECK: async.runtime.set_available %[[RETURNED_STORAGE]] // CHECK: async.runtime.set_available %[[RETURNED_STORAGE]]
// CHECK: async.runtime.set_available %[[TOKEN]] // CHECK: async.runtime.set_available %[[TOKEN]]
// CHECK: br ^[[CLEANUP]] // CHECK: cf.br ^[[CLEANUP]]
return %r: f32 return %r: f32
// CHECK: ^[[BRANCH_ERROR]]: // CHECK: ^[[BRANCH_ERROR]]:
// CHECK: async.runtime.set_error %[[TOKEN]] // CHECK: async.runtime.set_error %[[TOKEN]]
// CHECK: async.runtime.set_error %[[RETURNED_STORAGE]] // CHECK: async.runtime.set_error %[[RETURNED_STORAGE]]
// CHECK: br ^[[CLEANUP]] // CHECK: cf.br ^[[CLEANUP]]
// CHECK: ^[[CLEANUP]]: // CHECK: ^[[CLEANUP]]:
// CHECK: async.coro.free %[[ID]], %[[HDL]] // CHECK: async.coro.free %[[ID]], %[[HDL]]
// CHECK: br ^[[SUSPEND]] // CHECK: cf.br ^[[SUSPEND]]
// CHECK: ^[[SUSPEND]]: // CHECK: ^[[SUSPEND]]:
// CHECK: async.coro.end %[[HDL]] // CHECK: async.coro.end %[[HDL]]
// CHECK: return %[[TOKEN]], %[[RETURNED_STORAGE]] : !async.token, !async.value<f32> // CHECK: return %[[TOKEN]], %[[RETURNED_STORAGE]] : !async.token, !async.value<f32>
} }
// CHECK-LABEL: func @double_caller() // CHECK-LABEL: func @double_caller()
// CHECK-SAME: -> (!async.token, !async.value<f32>) // CHECK-SAME: -> (!async.token, !async.value<f32>)
func @double_caller() -> f32 { func @double_caller() -> f32 {
// CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token // CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token
// CHECK: %[[RETURNED_STORAGE:.*]] = async.runtime.create : !async.value<f32> // CHECK: %[[RETURNED_STORAGE:.*]] = async.runtime.create : !async.value<f32>
// CHECK: %[[ID:.*]] = async.coro.id // CHECK: %[[ID:.*]] = async.coro.id
// CHECK: %[[HDL:.*]] = async.coro.begin %[[ID]] // CHECK: %[[HDL:.*]] = async.coro.begin %[[ID]]
// CHECK: br ^[[ORIGINAL_ENTRY:.*]] // CHECK: cf.br ^[[ORIGINAL_ENTRY:.*]]
// CHECK ^[[ORIGINAL_ENTRY]]: // CHECK ^[[ORIGINAL_ENTRY]]:
// CHECK: %[[CONSTANT:.*]] = arith.constant // CHECK: %[[CONSTANT:.*]] = arith.constant
%c = arith.constant 1.0 : f32 %c = arith.constant 1.0 : f32
// CHECK: %[[RETURNED_TO_CALLER_1:.*]]:2 = call @simple_callee(%[[CONSTANT]]) : (f32) -> (!async.token, !async.value<f32>) // CHECK: %[[RETURNED_TO_CALLER_1:.*]]:2 = call @simple_callee(%[[CONSTANT]]) : (f32) -> (!async.token, !async.value<f32>)
// CHECK: %[[SAVED_1:.*]] = async.coro.save %[[HDL]] // CHECK: %[[SAVED_1:.*]] = async.coro.save %[[HDL]]
// CHECK: async.runtime.await_and_resume %[[RETURNED_TO_CALLER_1]]#0, %[[HDL]] // CHECK: async.runtime.await_and_resume %[[RETURNED_TO_CALLER_1]]#0, %[[HDL]]
// CHECK: async.coro.suspend %[[SAVED_1]] // CHECK: async.coro.suspend %[[SAVED_1]]
// CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_1:.*]], ^[[CLEANUP:.*]] // CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_1:.*]], ^[[CLEANUP:.*]]
%r = call @simple_callee(%c): (f32) -> f32 %r = call @simple_callee(%c): (f32) -> f32
// CHECK: ^[[RESUME_1]]: // CHECK: ^[[RESUME_1]]:
// CHECK: %[[IS_TOKEN_ERROR_1:.*]] = async.runtime.is_error %[[RETURNED_TO_CALLER_1]]#0 : !async.token // CHECK: %[[IS_TOKEN_ERROR_1:.*]] = async.runtime.is_error %[[RETURNED_TO_CALLER_1]]#0 : !async.token
// CHECK: cond_br %[[IS_TOKEN_ERROR_1]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_TOKEN_OK_1:.*]] // CHECK: cf.cond_br %[[IS_TOKEN_ERROR_1]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_TOKEN_OK_1:.*]]
// CHECK: ^[[BRANCH_TOKEN_OK_1]]: // CHECK: ^[[BRANCH_TOKEN_OK_1]]:
// CHECK: %[[IS_VALUE_ERROR_1:.*]] = async.runtime.is_error %[[RETURNED_TO_CALLER_1]]#1 : !async.value<f32> // CHECK: %[[IS_VALUE_ERROR_1:.*]] = async.runtime.is_error %[[RETURNED_TO_CALLER_1]]#1 : !async.value<f32>
// CHECK: cond_br %[[IS_VALUE_ERROR_1]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_VALUE_OK_1:.*]] // CHECK: cf.cond_br %[[IS_VALUE_ERROR_1]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_VALUE_OK_1:.*]]
// CHECK: ^[[BRANCH_VALUE_OK_1]]: // CHECK: ^[[BRANCH_VALUE_OK_1]]:
// CHECK: %[[LOADED_1:.*]] = async.runtime.load %[[RETURNED_TO_CALLER_1]]#1 : <f32> // CHECK: %[[LOADED_1:.*]] = async.runtime.load %[[RETURNED_TO_CALLER_1]]#1 : <f32>
// CHECK: %[[RETURNED_TO_CALLER_2:.*]]:2 = call @simple_callee(%[[LOADED_1]]) : (f32) -> (!async.token, !async.value<f32>) // CHECK: %[[RETURNED_TO_CALLER_2:.*]]:2 = call @simple_callee(%[[LOADED_1]]) : (f32) -> (!async.token, !async.value<f32>)
// CHECK: %[[SAVED_2:.*]] = async.coro.save %[[HDL]] // CHECK: %[[SAVED_2:.*]] = async.coro.save %[[HDL]]
// CHECK: async.runtime.await_and_resume %[[RETURNED_TO_CALLER_2]]#0, %[[HDL]] // CHECK: async.runtime.await_and_resume %[[RETURNED_TO_CALLER_2]]#0, %[[HDL]]
// CHECK: async.coro.suspend %[[SAVED_2]] // CHECK: async.coro.suspend %[[SAVED_2]]
// CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_2:.*]], ^[[CLEANUP:.*]] // CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_2:.*]], ^[[CLEANUP:.*]]
%s = call @simple_callee(%r): (f32) -> f32 %s = call @simple_callee(%r): (f32) -> f32
// CHECK: ^[[RESUME_2]]: // CHECK: ^[[RESUME_2]]:
// CHECK: %[[IS_TOKEN_ERROR_2:.*]] = async.runtime.is_error %[[RETURNED_TO_CALLER_2]]#0 : !async.token // CHECK: %[[IS_TOKEN_ERROR_2:.*]] = async.runtime.is_error %[[RETURNED_TO_CALLER_2]]#0 : !async.token
// CHECK: cond_br %[[IS_TOKEN_ERROR_2]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_TOKEN_OK_2:.*]] // CHECK: cf.cond_br %[[IS_TOKEN_ERROR_2]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_TOKEN_OK_2:.*]]
// CHECK: ^[[BRANCH_TOKEN_OK_2]]: // CHECK: ^[[BRANCH_TOKEN_OK_2]]:
// CHECK: %[[IS_VALUE_ERROR_2:.*]] = async.runtime.is_error %[[RETURNED_TO_CALLER_2]]#1 : !async.value<f32> // CHECK: %[[IS_VALUE_ERROR_2:.*]] = async.runtime.is_error %[[RETURNED_TO_CALLER_2]]#1 : !async.value<f32>
// CHECK: cond_br %[[IS_VALUE_ERROR_2]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_VALUE_OK_2:.*]] // CHECK: cf.cond_br %[[IS_VALUE_ERROR_2]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_VALUE_OK_2:.*]]
// CHECK: ^[[BRANCH_VALUE_OK_2]]: // CHECK: ^[[BRANCH_VALUE_OK_2]]:
// CHECK: %[[LOADED_2:.*]] = async.runtime.load %[[RETURNED_TO_CALLER_2]]#1 : <f32> // CHECK: %[[LOADED_2:.*]] = async.runtime.load %[[RETURNED_TO_CALLER_2]]#1 : <f32>
// CHECK: async.runtime.store %[[LOADED_2]], %[[RETURNED_STORAGE]] : <f32> // CHECK: async.runtime.store %[[LOADED_2]], %[[RETURNED_STORAGE]] : <f32>
// CHECK: async.runtime.set_available %[[RETURNED_STORAGE]] // CHECK: async.runtime.set_available %[[RETURNED_STORAGE]]
// CHECK: async.runtime.set_available %[[TOKEN]] // CHECK: async.runtime.set_available %[[TOKEN]]
// CHECK: br ^[[CLEANUP]] // CHECK: cf.br ^[[CLEANUP]]
return %s: f32 return %s: f32
// CHECK: ^[[BRANCH_ERROR]]: // CHECK: ^[[BRANCH_ERROR]]:
// CHECK: async.runtime.set_error %[[TOKEN]] // CHECK: async.runtime.set_error %[[TOKEN]]
// CHECK: async.runtime.set_error %[[RETURNED_STORAGE]] // CHECK: async.runtime.set_error %[[RETURNED_STORAGE]]
// CHECK: br ^[[CLEANUP]] // CHECK: cf.br ^[[CLEANUP]]
// CHECK: ^[[CLEANUP]]: // CHECK: ^[[CLEANUP]]:
// CHECK: async.coro.free %[[ID]], %[[HDL]] // CHECK: async.coro.free %[[ID]], %[[HDL]]
// CHECK: br ^[[SUSPEND]] // CHECK: cf.br ^[[SUSPEND]]
// CHECK: ^[[SUSPEND]]: // CHECK: ^[[SUSPEND]]:
// CHECK: async.coro.end %[[HDL]] // CHECK: async.coro.end %[[HDL]]
// CHECK: return %[[TOKEN]], %[[RETURNED_STORAGE]] : !async.token, !async.value<f32> // CHECK: return %[[TOKEN]], %[[RETURNED_STORAGE]] : !async.token, !async.value<f32>
} }
// CHECK-LABEL: func @recursive // CHECK-LABEL: func @recursive
// CHECK-SAME: (%[[ARG:.*]]: !async.token) -> !async.token // CHECK-SAME: (%[[ARG:.*]]: !async.token) -> !async.token
func @recursive(%arg: !async.token) { func @recursive(%arg: !async.token) {
// CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token // CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token
// CHECK: %[[ID:.*]] = async.coro.id // CHECK: %[[ID:.*]] = async.coro.id
// CHECK: %[[HDL:.*]] = async.coro.begin %[[ID]] // CHECK: %[[HDL:.*]] = async.coro.begin %[[ID]]
// CHECK: %[[SAVED_1:.*]] = async.coro.save %[[HDL]] // CHECK: %[[SAVED_1:.*]] = async.coro.save %[[HDL]]
// CHECK: async.runtime.await_and_resume %[[ARG]], %[[HDL]] // CHECK: async.runtime.await_and_resume %[[ARG]], %[[HDL]]
// CHECK: async.coro.suspend %[[SAVED_1]] // CHECK: async.coro.suspend %[[SAVED_1]]
// CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_1:.*]], ^[[CLEANUP:.*]] // CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_1:.*]], ^[[CLEANUP:.*]]
async.await %arg : !async.token async.await %arg : !async.token
// CHECK: ^[[RESUME_1]]: // CHECK: ^[[RESUME_1]]:
// CHECK: %[[IS_ERROR:.*]] = async.runtime.is_error %[[ARG]] : !async.token // CHECK: %[[IS_ERROR:.*]] = async.runtime.is_error %[[ARG]] : !async.token
// CHECK: cond_br %[[IS_ERROR]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_OK:.*]] // CHECK: cf.cond_br %[[IS_ERROR]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_OK:.*]]
// CHECK: ^[[BRANCH_OK]]: // CHECK: ^[[BRANCH_OK]]:
// CHECK: %[[GIVEN:.*]] = async.runtime.create : !async.token // CHECK: %[[GIVEN:.*]] = async.runtime.create : !async.token
%r = async.runtime.create : !async.token %r = async.runtime.create : !async.token
// CHECK: async.runtime.set_available %[[GIVEN]] // CHECK: async.runtime.set_available %[[GIVEN]]
async.runtime.set_available %r: !async.token async.runtime.set_available %r: !async.token
// CHECK: %[[RETURNED_TO_CALLER:.*]] = call @recursive(%[[GIVEN]]) : (!async.token) -> !async.token // CHECK: %[[RETURNED_TO_CALLER:.*]] = call @recursive(%[[GIVEN]]) : (!async.token) -> !async.token
call @recursive(%r): (!async.token) -> () call @recursive(%r): (!async.token) -> ()
// CHECK: %[[SAVED_2:.*]] = async.coro.save %[[HDL]] // CHECK: %[[SAVED_2:.*]] = async.coro.save %[[HDL]]
// CHECK: async.runtime.await_and_resume %[[RETURNED_TO_CALLER]], %[[HDL]] // CHECK: async.runtime.await_and_resume %[[RETURNED_TO_CALLER]], %[[HDL]]
// CHECK: async.coro.suspend %[[SAVED_2]] // CHECK: async.coro.suspend %[[SAVED_2]]
// CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_2:.*]], ^[[CLEANUP:.*]] // CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_2:.*]], ^[[CLEANUP:.*]]
// CHECK: ^[[RESUME_2]]: // CHECK: ^[[RESUME_2]]:
// CHECK: async.runtime.set_available %[[TOKEN]] // CHECK: async.runtime.set_available %[[TOKEN]]
// CHECK: br ^[[CLEANUP]] // CHECK: cf.br ^[[CLEANUP]]
// CHECK: ^[[BRANCH_ERROR]]: // CHECK: ^[[BRANCH_ERROR]]:
// CHECK: async.runtime.set_error %[[TOKEN]] // CHECK: async.runtime.set_error %[[TOKEN]]
// CHECK: br ^[[CLEANUP]] // CHECK: cf.br ^[[CLEANUP]]
return return
// CHECK: ^[[CLEANUP]]: // CHECK: ^[[CLEANUP]]:
// CHECK: async.coro.free %[[ID]], %[[HDL]] // CHECK: async.coro.free %[[ID]], %[[HDL]]
// CHECK: br ^[[SUSPEND]] // CHECK: cf.br ^[[SUSPEND]]
// CHECK: ^[[SUSPEND]]: // CHECK: ^[[SUSPEND]]:
// CHECK: async.coro.end %[[HDL]] // CHECK: async.coro.end %[[HDL]]
// CHECK: return %[[TOKEN]] : !async.token // CHECK: return %[[TOKEN]] : !async.token
} }
// CHECK-LABEL: func @corecursive1 // CHECK-LABEL: func @corecursive1
// CHECK-SAME: (%[[ARG:.*]]: !async.token) -> !async.token // CHECK-SAME: (%[[ARG:.*]]: !async.token) -> !async.token
func @corecursive1(%arg: !async.token) { func @corecursive1(%arg: !async.token) {
// CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token // CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token
// CHECK: %[[ID:.*]] = async.coro.id // CHECK: %[[ID:.*]] = async.coro.id
// CHECK: %[[HDL:.*]] = async.coro.begin %[[ID]] // CHECK: %[[HDL:.*]] = async.coro.begin %[[ID]]
// CHECK: %[[SAVED_1:.*]] = async.coro.save %[[HDL]] // CHECK: %[[SAVED_1:.*]] = async.coro.save %[[HDL]]
// CHECK: async.runtime.await_and_resume %[[ARG]], %[[HDL]] // CHECK: async.runtime.await_and_resume %[[ARG]], %[[HDL]]
// CHECK: async.coro.suspend %[[SAVED_1]] // CHECK: async.coro.suspend %[[SAVED_1]]
// CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_1:.*]], ^[[CLEANUP:.*]] // CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_1:.*]], ^[[CLEANUP:.*]]
async.await %arg : !async.token async.await %arg : !async.token
// CHECK: ^[[RESUME_1]]: // CHECK: ^[[RESUME_1]]:
// CHECK: %[[IS_ERROR:.*]] = async.runtime.is_error %[[ARG]] : !async.token // CHECK: %[[IS_ERROR:.*]] = async.runtime.is_error %[[ARG]] : !async.token
// CHECK: cond_br %[[IS_ERROR]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_OK:.*]] // CHECK: cf.cond_br %[[IS_ERROR]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_OK:.*]]
// CHECK: ^[[BRANCH_OK]]: // CHECK: ^[[BRANCH_OK]]:
// CHECK: %[[GIVEN:.*]] = async.runtime.create : !async.token // CHECK: %[[GIVEN:.*]] = async.runtime.create : !async.token
%r = async.runtime.create : !async.token %r = async.runtime.create : !async.token
// CHECK: async.runtime.set_available %[[GIVEN]] // CHECK: async.runtime.set_available %[[GIVEN]]
async.runtime.set_available %r: !async.token async.runtime.set_available %r: !async.token
// CHECK: %[[RETURNED_TO_CALLER:.*]] = call @corecursive2(%[[GIVEN]]) : (!async.token) -> !async.token // CHECK: %[[RETURNED_TO_CALLER:.*]] = call @corecursive2(%[[GIVEN]]) : (!async.token) -> !async.token
call @corecursive2(%r): (!async.token) -> () call @corecursive2(%r): (!async.token) -> ()
// CHECK: %[[SAVED_2:.*]] = async.coro.save %[[HDL]] // CHECK: %[[SAVED_2:.*]] = async.coro.save %[[HDL]]
// CHECK: async.runtime.await_and_resume %[[RETURNED_TO_CALLER]], %[[HDL]] // CHECK: async.runtime.await_and_resume %[[RETURNED_TO_CALLER]], %[[HDL]]
// CHECK: async.coro.suspend %[[SAVED_2]] // CHECK: async.coro.suspend %[[SAVED_2]]
// CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_2:.*]], ^[[CLEANUP:.*]] // CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_2:.*]], ^[[CLEANUP:.*]]
// CHECK: ^[[RESUME_2]]: // CHECK: ^[[RESUME_2]]:
// CHECK: async.runtime.set_available %[[TOKEN]] // CHECK: async.runtime.set_available %[[TOKEN]]
// CHECK: br ^[[CLEANUP]] // CHECK: cf.br ^[[CLEANUP]]
// CHECK: ^[[BRANCH_ERROR]]: // CHECK: ^[[BRANCH_ERROR]]:
// CHECK: async.runtime.set_error %[[TOKEN]] // CHECK: async.runtime.set_error %[[TOKEN]]
// CHECK: br ^[[CLEANUP]] // CHECK: cf.br ^[[CLEANUP]]
return return
// CHECK: ^[[CLEANUP]]: // CHECK: ^[[CLEANUP]]:
// CHECK: async.coro.free %[[ID]], %[[HDL]] // CHECK: async.coro.free %[[ID]], %[[HDL]]
// CHECK: br ^[[SUSPEND]] // CHECK: cf.br ^[[SUSPEND]]
// CHECK: ^[[SUSPEND]]: // CHECK: ^[[SUSPEND]]:
// CHECK: async.coro.end %[[HDL]] // CHECK: async.coro.end %[[HDL]]
// CHECK: return %[[TOKEN]] : !async.token // CHECK: return %[[TOKEN]] : !async.token
} }
// CHECK-LABEL: func @corecursive2 // CHECK-LABEL: func @corecursive2
// CHECK-SAME: (%[[ARG:.*]]: !async.token) -> !async.token // CHECK-SAME: (%[[ARG:.*]]: !async.token) -> !async.token
func @corecursive2(%arg: !async.token) { func @corecursive2(%arg: !async.token) {
// CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token // CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token
// CHECK: %[[ID:.*]] = async.coro.id // CHECK: %[[ID:.*]] = async.coro.id
// CHECK: %[[HDL:.*]] = async.coro.begin %[[ID]] // CHECK: %[[HDL:.*]] = async.coro.begin %[[ID]]
// CHECK: %[[SAVED_1:.*]] = async.coro.save %[[HDL]] // CHECK: %[[SAVED_1:.*]] = async.coro.save %[[HDL]]
// CHECK: async.runtime.await_and_resume %[[ARG]], %[[HDL]] // CHECK: async.runtime.await_and_resume %[[ARG]], %[[HDL]]
// CHECK: async.coro.suspend %[[SAVED_1]] // CHECK: async.coro.suspend %[[SAVED_1]]
// CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_1:.*]], ^[[CLEANUP:.*]] // CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_1:.*]], ^[[CLEANUP:.*]]
async.await %arg : !async.token async.await %arg : !async.token
// CHECK: ^[[RESUME_1]]: // CHECK: ^[[RESUME_1]]:
// CHECK: %[[IS_ERROR:.*]] = async.runtime.is_error %[[ARG]] : !async.token // CHECK: %[[IS_ERROR:.*]] = async.runtime.is_error %[[ARG]] : !async.token
// CHECK: cond_br %[[IS_ERROR]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_OK:.*]] // CHECK: cf.cond_br %[[IS_ERROR]], ^[[BRANCH_ERROR:.*]], ^[[BRANCH_OK:.*]]
// CHECK: ^[[BRANCH_OK]]: // CHECK: ^[[BRANCH_OK]]:
// CHECK: %[[GIVEN:.*]] = async.runtime.create : !async.token // CHECK: %[[GIVEN:.*]] = async.runtime.create : !async.token
%r = async.runtime.create : !async.token %r = async.runtime.create : !async.token
// CHECK: async.runtime.set_available %[[GIVEN]] // CHECK: async.runtime.set_available %[[GIVEN]]
async.runtime.set_available %r: !async.token async.runtime.set_available %r: !async.token
// CHECK: %[[RETURNED_TO_CALLER:.*]] = call @corecursive1(%[[GIVEN]]) : (!async.token) -> !async.token // CHECK: %[[RETURNED_TO_CALLER:.*]] = call @corecursive1(%[[GIVEN]]) : (!async.token) -> !async.token
call @corecursive1(%r): (!async.token) -> () call @corecursive1(%r): (!async.token) -> ()
// CHECK: %[[SAVED_2:.*]] = async.coro.save %[[HDL]] // CHECK: %[[SAVED_2:.*]] = async.coro.save %[[HDL]]
// CHECK: async.runtime.await_and_resume %[[RETURNED_TO_CALLER]], %[[HDL]] // CHECK: async.runtime.await_and_resume %[[RETURNED_TO_CALLER]], %[[HDL]]
// CHECK: async.coro.suspend %[[SAVED_2]] // CHECK: async.coro.suspend %[[SAVED_2]]
// CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_2:.*]], ^[[CLEANUP:.*]] // CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME_2:.*]], ^[[CLEANUP:.*]]
// CHECK: ^[[RESUME_2]]: // CHECK: ^[[RESUME_2]]:
// CHECK: async.runtime.set_available %[[TOKEN]] // CHECK: async.runtime.set_available %[[TOKEN]]
// CHECK: br ^[[CLEANUP]] // CHECK: cf.br ^[[CLEANUP]]
// CHECK: ^[[BRANCH_ERROR]]: // CHECK: ^[[BRANCH_ERROR]]:
// CHECK: async.runtime.set_error %[[TOKEN]] // CHECK: async.runtime.set_error %[[TOKEN]]
// CHECK: br ^[[CLEANUP]] // CHECK: cf.br ^[[CLEANUP]]
return return
// CHECK: ^[[CLEANUP]]: // CHECK: ^[[CLEANUP]]:
// CHECK: async.coro.free %[[ID]], %[[HDL]] // CHECK: async.coro.free %[[ID]], %[[HDL]]
// CHECK: br ^[[SUSPEND]] // CHECK: cf.br ^[[SUSPEND]]
// CHECK: ^[[SUSPEND]]: // CHECK: ^[[SUSPEND]]:
// CHECK: async.coro.end %[[HDL]] // CHECK: async.coro.end %[[HDL]]
// CHECK: return %[[TOKEN]] : !async.token // CHECK: return %[[TOKEN]] : !async.token
} }
// CHECK-LABEL: func @caller_allowed_to_block // CHECK-LABEL: func @caller_allowed_to_block
// CHECK-SAME: () -> f32 // CHECK-SAME: () -> f32
Show All 12 Lines

mlir/test/Dialect/Async/async-to-async-runtime.mlir

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines %token0 = async.execute {
memref.store %arg1, %arg2[%c0] : memref<1xf32> memref.store %arg1, %arg2[%c0] : memref<1xf32>
async.yield async.yield
} }
// CHECK: async.runtime.await %[[TOKEN]] // CHECK: async.runtime.await %[[TOKEN]]
// CHECK: %[[IS_ERROR:.*]] = async.runtime.is_error %[[TOKEN]] // CHECK: %[[IS_ERROR:.*]] = async.runtime.is_error %[[TOKEN]]
// CHECK: %[[TRUE:.*]] = arith.constant true // CHECK: %[[TRUE:.*]] = arith.constant true
// CHECK: %[[NOT_ERROR:.*]] = arith.xori %[[IS_ERROR]], %[[TRUE]] : i1 // CHECK: %[[NOT_ERROR:.*]] = arith.xori %[[IS_ERROR]], %[[TRUE]] : i1
// CHECK: assert %[[NOT_ERROR]] // CHECK: cf.assert %[[NOT_ERROR]]
// CHECK-NEXT: return // CHECK-NEXT: return
async.await %token0 : !async.token async.await %token0 : !async.token
return return
} }
// Function outlined from the inner async.execute operation. // Function outlined from the inner async.execute operation.
// CHECK-LABEL: func private @async_execute_fn // CHECK-LABEL: func private @async_execute_fn
// CHECK-SAME: -> !async.token // CHECK-SAME: -> !async.token
Show All 29 Lines
// CHECK: %[[SAVED:.*]] = async.coro.save %[[HDL]] // CHECK: %[[SAVED:.*]] = async.coro.save %[[HDL]]
// CHECK: async.runtime.await_and_resume %[[INNER_TOKEN]], %[[HDL]] // CHECK: async.runtime.await_and_resume %[[INNER_TOKEN]], %[[HDL]]
// CHECK: async.coro.suspend %[[SAVED]] // CHECK: async.coro.suspend %[[SAVED]]
// CHECK-SAME: ^[[SUSPEND]], ^[[RESUME_1:.*]], ^[[CLEANUP]] // CHECK-SAME: ^[[SUSPEND]], ^[[RESUME_1:.*]], ^[[CLEANUP]]
// Check the error of the awaited token after resumption. // Check the error of the awaited token after resumption.
// CHECK: ^[[RESUME_1]]: // CHECK: ^[[RESUME_1]]:
// CHECK: %[[ERR:.*]] = async.runtime.is_error %[[INNER_TOKEN]] // CHECK: %[[ERR:.*]] = async.runtime.is_error %[[INNER_TOKEN]]
// CHECK: cond_br %[[ERR]], ^[[SET_ERROR:.*]], ^[[CONTINUATION:.*]] // CHECK: cf.cond_br %[[ERR]], ^[[SET_ERROR:.*]], ^[[CONTINUATION:.*]]
// Set token available if the token is not in the error state. // Set token available if the token is not in the error state.
// CHECK: ^[[CONTINUATION:.*]]: // CHECK: ^[[CONTINUATION:.*]]:
// CHECK: memref.store // CHECK: memref.store
// CHECK: async.runtime.set_available %[[TOKEN]] // CHECK: async.runtime.set_available %[[TOKEN]]
// CHECK: ^[[SET_ERROR]]: // CHECK: ^[[SET_ERROR]]:
// CHECK: ^[[CLEANUP]]: // CHECK: ^[[CLEANUP]]:
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
// CHECK: %[[SAVED:.*]] = async.coro.save %[[HDL]] // CHECK: %[[SAVED:.*]] = async.coro.save %[[HDL]]
// CHECK: async.runtime.await_and_resume %[[ARG0]], %[[HDL]] // CHECK: async.runtime.await_and_resume %[[ARG0]], %[[HDL]]
// CHECK: async.coro.suspend %[[SAVED]] // CHECK: async.coro.suspend %[[SAVED]]
// CHECK-SAME: ^[[SUSPEND]], ^[[RESUME_1:.*]], ^[[CLEANUP]] // CHECK-SAME: ^[[SUSPEND]], ^[[RESUME_1:.*]], ^[[CLEANUP]]
// Check the error of the awaited token after resumption. // Check the error of the awaited token after resumption.
// CHECK: ^[[RESUME_1]]: // CHECK: ^[[RESUME_1]]:
// CHECK: %[[ERR:.*]] = async.runtime.is_error %[[ARG0]] // CHECK: %[[ERR:.*]] = async.runtime.is_error %[[ARG0]]
// CHECK: cond_br %[[ERR]], ^[[SET_ERROR:.*]], ^[[CONTINUATION:.*]] // CHECK: cf.cond_br %[[ERR]], ^[[SET_ERROR:.*]], ^[[CONTINUATION:.*]]
// Emplace result token after second resumption and error checking. // Emplace result token after second resumption and error checking.
// CHECK: ^[[CONTINUATION:.*]]: // CHECK: ^[[CONTINUATION:.*]]:
// CHECK: memref.store // CHECK: memref.store
// CHECK: async.runtime.set_available %[[TOKEN]] // CHECK: async.runtime.set_available %[[TOKEN]]
// CHECK: ^[[CLEANUP]]: // CHECK: ^[[CLEANUP]]:
// CHECK: ^[[SUSPEND]]: // CHECK: ^[[SUSPEND]]:
Show All 39 Lines
// CHECK: ^[[RESUME_0]]: // CHECK: ^[[RESUME_0]]:
// CHECK: async.runtime.await_and_resume %[[ARG]], %[[HDL]] // CHECK: async.runtime.await_and_resume %[[ARG]], %[[HDL]]
// CHECK: async.coro.suspend // CHECK: async.coro.suspend
// CHECK-SAME: ^[[SUSPEND]], ^[[RESUME_1:.*]], ^[[CLEANUP]] // CHECK-SAME: ^[[SUSPEND]], ^[[RESUME_1:.*]], ^[[CLEANUP]]
// Check the error of the awaited token after resumption. // Check the error of the awaited token after resumption.
// CHECK: ^[[RESUME_1]]: // CHECK: ^[[RESUME_1]]:
// CHECK: %[[ERR:.*]] = async.runtime.is_error %[[ARG]] // CHECK: %[[ERR:.*]] = async.runtime.is_error %[[ARG]]
// CHECK: cond_br %[[ERR]], ^[[SET_ERROR:.*]], ^[[CONTINUATION:.*]] // CHECK: cf.cond_br %[[ERR]], ^[[SET_ERROR:.*]], ^[[CONTINUATION:.*]]
// Emplace result token after error checking. // Emplace result token after error checking.
// CHECK: ^[[CONTINUATION:.*]]: // CHECK: ^[[CONTINUATION:.*]]:
// CHECK: async.runtime.set_available %[[TOKEN]] // CHECK: async.runtime.set_available %[[TOKEN]]
// CHECK: ^[[CLEANUP]]: // CHECK: ^[[CLEANUP]]:
// CHECK: ^[[SUSPEND]]: // CHECK: ^[[SUSPEND]]:
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
// CHECK: ^[[RESUME_0]]: // CHECK: ^[[RESUME_0]]:
// CHECK: async.runtime.await_and_resume %[[ARG]], %[[HDL]] // CHECK: async.runtime.await_and_resume %[[ARG]], %[[HDL]]
// CHECK: async.coro.suspend // CHECK: async.coro.suspend
// CHECK-SAME: ^[[SUSPEND]], ^[[RESUME_1:.*]], ^[[CLEANUP]] // CHECK-SAME: ^[[SUSPEND]], ^[[RESUME_1:.*]], ^[[CLEANUP]]
// Check the error of the awaited token after resumption. // Check the error of the awaited token after resumption.
// CHECK: ^[[RESUME_1]]: // CHECK: ^[[RESUME_1]]:
// CHECK: %[[ERR:.*]] = async.runtime.is_error %[[ARG]] // CHECK: %[[ERR:.*]] = async.runtime.is_error %[[ARG]]
// CHECK: cond_br %[[ERR]], ^[[SET_ERROR:.*]], ^[[CONTINUATION:.*]] // CHECK: cf.cond_br %[[ERR]], ^[[SET_ERROR:.*]], ^[[CONTINUATION:.*]]
// // Load from the async.value argument after error checking. // // Load from the async.value argument after error checking.
// CHECK: ^[[CONTINUATION:.*]]: // CHECK: ^[[CONTINUATION:.*]]:
// CHECK: %[[LOADED:.*]] = async.runtime.load %[[ARG]] : <f32 // CHECK: %[[LOADED:.*]] = async.runtime.load %[[ARG]] : <f32
// CHECK: arith.addf %[[LOADED]], %[[LOADED]] : f32 // CHECK: arith.addf %[[LOADED]], %[[LOADED]] : f32
// CHECK: async.runtime.set_available %[[TOKEN]] // CHECK: async.runtime.set_available %[[TOKEN]]
// CHECK: ^[[CLEANUP]]: // CHECK: ^[[CLEANUP]]:
// CHECK: ^[[SUSPEND]]: // CHECK: ^[[SUSPEND]]:
// ----- // -----
// CHECK-LABEL: @execute_assertion // CHECK-LABEL: @execute_assertion
func @execute_assertion(%arg0: i1) { func @execute_assertion(%arg0: i1) {
%token = async.execute { %token = async.execute {
assert %arg0, "error" cf.assert %arg0, "error"
async.yield async.yield
} }
async.await %token : !async.token async.await %token : !async.token
return return
} }
// Function outlined from the async.execute operation. // Function outlined from the async.execute operation.
// CHECK-LABEL: func private @async_execute_fn( // CHECK-LABEL: func private @async_execute_fn(
// CHECK-SAME: %[[ARG0:.*]]: i1 // CHECK-SAME: %[[ARG0:.*]]: i1
// CHECK-SAME: -> !async.token // CHECK-SAME: -> !async.token
// Create token for return op, and mark a function as a coroutine. // Create token for return op, and mark a function as a coroutine.
// CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token // CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token
// CHECK: %[[ID:.*]] = async.coro.id // CHECK: %[[ID:.*]] = async.coro.id
// CHECK: %[[HDL:.*]] = async.coro.begin // CHECK: %[[HDL:.*]] = async.coro.begin
// Initial coroutine suspension. // Initial coroutine suspension.
// CHECK: async.coro.suspend // CHECK: async.coro.suspend
// CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME:.*]], ^[[CLEANUP:.*]] // CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME:.*]], ^[[CLEANUP:.*]]
// Resume coroutine after suspension. // Resume coroutine after suspension.
// CHECK: ^[[RESUME]]: // CHECK: ^[[RESUME]]:
// CHECK: cond_br %[[ARG0]], ^[[SET_AVAILABLE:.*]], ^[[SET_ERROR:.*]] // CHECK: cf.cond_br %[[ARG0]], ^[[SET_AVAILABLE:.*]], ^[[SET_ERROR:.*]]
// Set coroutine completion token to available state. // Set coroutine completion token to available state.
// CHECK: ^[[SET_AVAILABLE]]: // CHECK: ^[[SET_AVAILABLE]]:
// CHECK: async.runtime.set_available %[[TOKEN]] // CHECK: async.runtime.set_available %[[TOKEN]]
// CHECK: br ^[[CLEANUP]] // CHECK: cf.br ^[[CLEANUP]]
// Set coroutine completion token to error state. // Set coroutine completion token to error state.
// CHECK: ^[[SET_ERROR]]: // CHECK: ^[[SET_ERROR]]:
// CHECK: async.runtime.set_error %[[TOKEN]] // CHECK: async.runtime.set_error %[[TOKEN]]
// CHECK: br ^[[CLEANUP]] // CHECK: cf.br ^[[CLEANUP]]
// Delete coroutine. // Delete coroutine.
// CHECK: ^[[CLEANUP]]: // CHECK: ^[[CLEANUP]]:
// CHECK: async.coro.free %[[ID]], %[[HDL]] // CHECK: async.coro.free %[[ID]], %[[HDL]]
// Suspend coroutine, and also a return statement for ramp function. // Suspend coroutine, and also a return statement for ramp function.
// CHECK: ^[[SUSPEND]]: // CHECK: ^[[SUSPEND]]:
// CHECK: async.coro.end %[[HDL]] // CHECK: async.coro.end %[[HDL]]
Show All 24 Lines
// Function outlined from the second async.execute operation. // Function outlined from the second async.execute operation.
// CHECK-LABEL: func private @async_execute_fn_0( // CHECK-LABEL: func private @async_execute_fn_0(
// CHECK: %[[TOKEN:.*]]: !async.token // CHECK: %[[TOKEN:.*]]: !async.token
// CHECK: %[[FLAG:.*]]: i1 // CHECK: %[[FLAG:.*]]: i1
// CHECK-SAME: -> !async.token // CHECK-SAME: -> !async.token
// Check that structured control flow lowered to CFG. // Check that structured control flow lowered to CFG.
// CHECK-NOT: scf.if // CHECK-NOT: scf.if
// CHECK: cond_br %[[FLAG]] // CHECK: cf.cond_br %[[FLAG]]
// ----- // -----
// Constants captured by the async.execute region should be cloned into the // Constants captured by the async.execute region should be cloned into the
// outline async execute function. // outline async execute function.
// CHECK-LABEL: @clone_constants // CHECK-LABEL: @clone_constants
func @clone_constants(%arg0: f32, %arg1: memref<1xf32>) { func @clone_constants(%arg0: f32, %arg1: memref<1xf32>) {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
Show All 15 Lines

mlir/test/Dialect/Bufferization/Transforms/buffer-deallocation.mlir

Show All 11 Lines
// bb3 // bb3
// BufferDeallocation expected behavior: bb2 contains an AllocOp which is // BufferDeallocation expected behavior: bb2 contains an AllocOp which is
// passed to bb3. In the latter block, there should be an deallocation. // passed to bb3. In the latter block, there should be an deallocation.
// Since bb1 does not contain an adequate alloc and the alloc in bb2 is not // Since bb1 does not contain an adequate alloc and the alloc in bb2 is not
// moved to bb0, we need to insert allocs and copies. // moved to bb0, we need to insert allocs and copies.
// CHECK-LABEL: func @condBranch // CHECK-LABEL: func @condBranch
func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK: %[[ALLOC0:.*]] = bufferization.clone // CHECK: %[[ALLOC0:.*]] = bufferization.clone
// CHECK-NEXT: br ^bb3(%[[ALLOC0]] // CHECK-NEXT: cf.br ^bb3(%[[ALLOC0]]
// CHECK: %[[ALLOC1:.*]] = memref.alloc // CHECK: %[[ALLOC1:.*]] = memref.alloc
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// CHECK-NEXT: %[[ALLOC2:.*]] = bufferization.clone %[[ALLOC1]] // CHECK-NEXT: %[[ALLOC2:.*]] = bufferization.clone %[[ALLOC1]]
// CHECK-NEXT: memref.dealloc %[[ALLOC1]] // CHECK-NEXT: memref.dealloc %[[ALLOC1]]
// CHECK-NEXT: br ^bb3(%[[ALLOC2]] // CHECK-NEXT: cf.br ^bb3(%[[ALLOC2]]
// CHECK: test.copy // CHECK: test.copy
// CHECK-NEXT: memref.dealloc // CHECK-NEXT: memref.dealloc
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// Test Case: // Test Case:
// bb0 // bb0
Show All 9 Lines
// to %2 in block bb3. // to %2 in block bb3.
// CHECK-LABEL: func @condBranchDynamicType // CHECK-LABEL: func @condBranchDynamicType
func @condBranchDynamicType( func @condBranchDynamicType(
%arg0: i1, %arg0: i1,
%arg1: memref<?xf32>, %arg1: memref<?xf32>,
%arg2: memref<?xf32>, %arg2: memref<?xf32>,
%arg3: index) { %arg3: index) {
cond_br %arg0, ^bb1, ^bb2(%arg3: index) cf.cond_br %arg0, ^bb1, ^bb2(%arg3: index)
^bb1: ^bb1:
br ^bb3(%arg1 : memref<?xf32>) cf.br ^bb3(%arg1 : memref<?xf32>)
^bb2(%0: index): ^bb2(%0: index):
%1 = memref.alloc(%0) : memref<?xf32> %1 = memref.alloc(%0) : memref<?xf32>
test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>) test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>)
br ^bb3(%1 : memref<?xf32>) cf.br ^bb3(%1 : memref<?xf32>)
^bb3(%2: memref<?xf32>): ^bb3(%2: memref<?xf32>):
test.copy(%2, %arg2) : (memref<?xf32>, memref<?xf32>) test.copy(%2, %arg2) : (memref<?xf32>, memref<?xf32>)
return return
} }
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK: %[[ALLOC0:.*]] = bufferization.clone // CHECK: %[[ALLOC0:.*]] = bufferization.clone
// CHECK-NEXT: br ^bb3(%[[ALLOC0]] // CHECK-NEXT: cf.br ^bb3(%[[ALLOC0]]
// CHECK: ^bb2(%[[IDX:.*]]:{{.*}}) // CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%[[IDX]]) // CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%[[IDX]])
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// CHECK-NEXT: %[[ALLOC2:.*]] = bufferization.clone // CHECK-NEXT: %[[ALLOC2:.*]] = bufferization.clone
// CHECK-NEXT: memref.dealloc %[[ALLOC1]] // CHECK-NEXT: memref.dealloc %[[ALLOC1]]
// CHECK-NEXT: br ^bb3 // CHECK-NEXT: cf.br ^bb3
// CHECK-NEXT: ^bb3(%[[ALLOC3:.*]]:{{.*}}) // CHECK-NEXT: ^bb3(%[[ALLOC3:.*]]:{{.*}})
// CHECK: test.copy(%[[ALLOC3]], // CHECK: test.copy(%[[ALLOC3]],
// CHECK-NEXT: memref.dealloc %[[ALLOC3]] // CHECK-NEXT: memref.dealloc %[[ALLOC3]]
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// Test case: See above. // Test case: See above.
// CHECK-LABEL: func @condBranchUnrankedType // CHECK-LABEL: func @condBranchUnrankedType
func @condBranchUnrankedType( func @condBranchUnrankedType(
%arg0: i1, %arg0: i1,
%arg1: memref<*xf32>, %arg1: memref<*xf32>,
%arg2: memref<*xf32>, %arg2: memref<*xf32>,
%arg3: index) { %arg3: index) {
cond_br %arg0, ^bb1, ^bb2(%arg3: index) cf.cond_br %arg0, ^bb1, ^bb2(%arg3: index)
^bb1: ^bb1:
br ^bb3(%arg1 : memref<*xf32>) cf.br ^bb3(%arg1 : memref<*xf32>)
^bb2(%0: index): ^bb2(%0: index):
%1 = memref.alloc(%0) : memref<?xf32> %1 = memref.alloc(%0) : memref<?xf32>
%2 = memref.cast %1 : memref<?xf32> to memref<*xf32> %2 = memref.cast %1 : memref<?xf32> to memref<*xf32>
test.buffer_based in(%arg1: memref<*xf32>) out(%2: memref<*xf32>) test.buffer_based in(%arg1: memref<*xf32>) out(%2: memref<*xf32>)
br ^bb3(%2 : memref<*xf32>) cf.br ^bb3(%2 : memref<*xf32>)
^bb3(%3: memref<*xf32>): ^bb3(%3: memref<*xf32>):
test.copy(%3, %arg2) : (memref<*xf32>, memref<*xf32>) test.copy(%3, %arg2) : (memref<*xf32>, memref<*xf32>)
return return
} }
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK: %[[ALLOC0:.*]] = bufferization.clone // CHECK: %[[ALLOC0:.*]] = bufferization.clone
// CHECK-NEXT: br ^bb3(%[[ALLOC0]] // CHECK-NEXT: cf.br ^bb3(%[[ALLOC0]]
// CHECK: ^bb2(%[[IDX:.*]]:{{.*}}) // CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%[[IDX]]) // CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%[[IDX]])
// CHECK: test.buffer_based // CHECK: test.buffer_based
// CHECK-NEXT: %[[ALLOC2:.*]] = bufferization.clone // CHECK-NEXT: %[[ALLOC2:.*]] = bufferization.clone
// CHECK-NEXT: memref.dealloc %[[ALLOC1]] // CHECK-NEXT: memref.dealloc %[[ALLOC1]]
// CHECK-NEXT: br ^bb3 // CHECK-NEXT: cf.br ^bb3
// CHECK-NEXT: ^bb3(%[[ALLOC3:.*]]:{{.*}}) // CHECK-NEXT: ^bb3(%[[ALLOC3:.*]]:{{.*}})
// CHECK: test.copy(%[[ALLOC3]], // CHECK: test.copy(%[[ALLOC3]],
// CHECK-NEXT: memref.dealloc %[[ALLOC3]] // CHECK-NEXT: memref.dealloc %[[ALLOC3]]
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// Test Case: // Test Case:
Show All 17 Lines
// bb6. Furthermore, there should be no copy inserted for %4. // bb6. Furthermore, there should be no copy inserted for %4.
// CHECK-LABEL: func @condBranchDynamicTypeNested // CHECK-LABEL: func @condBranchDynamicTypeNested
func @condBranchDynamicTypeNested( func @condBranchDynamicTypeNested(
%arg0: i1, %arg0: i1,
%arg1: memref<?xf32>, %arg1: memref<?xf32>,
%arg2: memref<?xf32>, %arg2: memref<?xf32>,
%arg3: index) { %arg3: index) {
cond_br %arg0, ^bb1, ^bb2(%arg3: index) cf.cond_br %arg0, ^bb1, ^bb2(%arg3: index)
^bb1: ^bb1:
br ^bb6(%arg1 : memref<?xf32>) cf.br ^bb6(%arg1 : memref<?xf32>)
^bb2(%0: index): ^bb2(%0: index):
%1 = memref.alloc(%0) : memref<?xf32> %1 = memref.alloc(%0) : memref<?xf32>
test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>) test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>)
cond_br %arg0, ^bb3, ^bb4 cf.cond_br %arg0, ^bb3, ^bb4
^bb3: ^bb3:
br ^bb5(%1 : memref<?xf32>) cf.br ^bb5(%1 : memref<?xf32>)
^bb4: ^bb4:
br ^bb5(%1 : memref<?xf32>) cf.br ^bb5(%1 : memref<?xf32>)
^bb5(%2: memref<?xf32>): ^bb5(%2: memref<?xf32>):
br ^bb6(%2 : memref<?xf32>) cf.br ^bb6(%2 : memref<?xf32>)
^bb6(%3: memref<?xf32>): ^bb6(%3: memref<?xf32>):
br ^bb7(%3 : memref<?xf32>) cf.br ^bb7(%3 : memref<?xf32>)
^bb7(%4: memref<?xf32>): ^bb7(%4: memref<?xf32>):
test.copy(%4, %arg2) : (memref<?xf32>, memref<?xf32>) test.copy(%4, %arg2) : (memref<?xf32>, memref<?xf32>)
return return
} }
// CHECK-NEXT: cond_br{{.*}} // CHECK-NEXT: cf.cond_br{{.*}}
// CHECK-NEXT: ^bb1 // CHECK-NEXT: ^bb1
// CHECK-NEXT: %[[ALLOC0:.*]] = bufferization.clone // CHECK-NEXT: %[[ALLOC0:.*]] = bufferization.clone
// CHECK-NEXT: br ^bb6(%[[ALLOC0]] // CHECK-NEXT: cf.br ^bb6(%[[ALLOC0]]
// CHECK: ^bb2(%[[IDX:.*]]:{{.*}}) // CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%[[IDX]]) // CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%[[IDX]])
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// CHECK: cond_br // CHECK: cf.cond_br
// CHECK: ^bb3: // CHECK: ^bb3:
// CHECK-NEXT: br ^bb5(%[[ALLOC1]]{{.*}}) // CHECK-NEXT: cf.br ^bb5(%[[ALLOC1]]{{.*}})
// CHECK: ^bb4: // CHECK: ^bb4:
// CHECK-NEXT: br ^bb5(%[[ALLOC1]]{{.*}}) // CHECK-NEXT: cf.br ^bb5(%[[ALLOC1]]{{.*}})
// CHECK-NEXT: ^bb5(%[[ALLOC2:.*]]:{{.*}}) // CHECK-NEXT: ^bb5(%[[ALLOC2:.*]]:{{.*}})
// CHECK-NEXT: %[[ALLOC3:.*]] = bufferization.clone %[[ALLOC2]] // CHECK-NEXT: %[[ALLOC3:.*]] = bufferization.clone %[[ALLOC2]]
// CHECK-NEXT: memref.dealloc %[[ALLOC1]] // CHECK-NEXT: memref.dealloc %[[ALLOC1]]
// CHECK-NEXT: br ^bb6(%[[ALLOC3]]{{.*}}) // CHECK-NEXT: cf.br ^bb6(%[[ALLOC3]]{{.*}})
// CHECK-NEXT: ^bb6(%[[ALLOC4:.*]]:{{.*}}) // CHECK-NEXT: ^bb6(%[[ALLOC4:.*]]:{{.*}})
// CHECK-NEXT: br ^bb7(%[[ALLOC4]]{{.*}}) // CHECK-NEXT: cf.br ^bb7(%[[ALLOC4]]{{.*}})
// CHECK-NEXT: ^bb7(%[[ALLOC5:.*]]:{{.*}}) // CHECK-NEXT: ^bb7(%[[ALLOC5:.*]]:{{.*}})
// CHECK: test.copy(%[[ALLOC5]], // CHECK: test.copy(%[[ALLOC5]],
// CHECK-NEXT: memref.dealloc %[[ALLOC4]] // CHECK-NEXT: memref.dealloc %[[ALLOC4]]
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// Test Case: Existing AllocOp with no users. // Test Case: Existing AllocOp with no users.
Show All 18 Lines
// \ / // \ /
// bb2 // bb2
// BufferDeallocation expected behavior: It should insert a DeallocOp at the // BufferDeallocation expected behavior: It should insert a DeallocOp at the
// exit block after CopyOp since %1 is an alias for %0 and %arg1. Furthermore, // exit block after CopyOp since %1 is an alias for %0 and %arg1. Furthermore,
// we have to insert a copy and an alloc in the beginning of the function. // we have to insert a copy and an alloc in the beginning of the function.
// CHECK-LABEL: func @criticalEdge // CHECK-LABEL: func @criticalEdge
func @criticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @criticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>) cf.cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>)
^bb1: ^bb1:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
br ^bb2(%0 : memref<2xf32>) cf.br ^bb2(%0 : memref<2xf32>)
^bb2(%1: memref<2xf32>): ^bb2(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOC0:.*]] = bufferization.clone // CHECK-NEXT: %[[ALLOC0:.*]] = bufferization.clone
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK: %[[ALLOC1:.*]] = memref.alloc() // CHECK: %[[ALLOC1:.*]] = memref.alloc()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// CHECK-NEXT: %[[ALLOC2:.*]] = bufferization.clone %[[ALLOC1]] // CHECK-NEXT: %[[ALLOC2:.*]] = bufferization.clone %[[ALLOC1]]
// CHECK-NEXT: memref.dealloc %[[ALLOC1]] // CHECK-NEXT: memref.dealloc %[[ALLOC1]]
// CHECK: test.copy // CHECK: test.copy
// CHECK-NEXT: memref.dealloc // CHECK-NEXT: memref.dealloc
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// Test Case: // Test Case:
// bb0 <- Initial position of AllocOp // bb0 <- Initial position of AllocOp
// / \ // / \
// | bb1 // | bb1
// \ / // \ /
// bb2 // bb2
// BufferDeallocation expected behavior: It only inserts a DeallocOp at the // BufferDeallocation expected behavior: It only inserts a DeallocOp at the
// exit block after CopyOp since %1 is an alias for %0 and %arg1. // exit block after CopyOp since %1 is an alias for %0 and %arg1.
// CHECK-LABEL: func @invCriticalEdge // CHECK-LABEL: func @invCriticalEdge
func @invCriticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @invCriticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>) cf.cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>)
^bb1: ^bb1:
br ^bb2(%0 : memref<2xf32>) cf.br ^bb2(%0 : memref<2xf32>)
^bb2(%1: memref<2xf32>): ^bb2(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK: dealloc // CHECK: dealloc
// CHECK-NEXT: return // CHECK-NEXT: return
Show All 9 Lines
// DeallocOps in the exit block. %5 is an alias for %0. Therefore, the // DeallocOps in the exit block. %5 is an alias for %0. Therefore, the
// DeallocOp for %0 should occur after the last BufferBasedOp. The Dealloc for // DeallocOp for %0 should occur after the last BufferBasedOp. The Dealloc for
// %7 should happen after CopyOp. // %7 should happen after CopyOp.
// CHECK-LABEL: func @ifElse // CHECK-LABEL: func @ifElse
func @ifElse(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @ifElse(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
cond_br %arg0, cf.cond_br %arg0,
^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>), ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>) ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
^bb1(%1: memref<2xf32>, %2: memref<2xf32>): ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>) cf.br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>)
^bb2(%3: memref<2xf32>, %4: memref<2xf32>): ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>) cf.br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>)
^bb3(%5: memref<2xf32>, %6: memref<2xf32>): ^bb3(%5: memref<2xf32>, %6: memref<2xf32>):
%7 = memref.alloc() : memref<2xf32> %7 = memref.alloc() : memref<2xf32>
test.buffer_based in(%5: memref<2xf32>) out(%7: memref<2xf32>) test.buffer_based in(%5: memref<2xf32>) out(%7: memref<2xf32>)
test.copy(%7, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%7, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[FIRST_ALLOC:.*]] = memref.alloc() // CHECK-NEXT: %[[FIRST_ALLOC:.*]] = memref.alloc()
Show All 15 Lines
// bb3 // bb3
// BufferDeallocation expected behavior: It only inserts a missing DeallocOp // BufferDeallocation expected behavior: It only inserts a missing DeallocOp
// in the exit block since %5 or %6 are the latest aliases of %0. // in the exit block since %5 or %6 are the latest aliases of %0.
// CHECK-LABEL: func @ifElseNoUsers // CHECK-LABEL: func @ifElseNoUsers
func @ifElseNoUsers(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @ifElseNoUsers(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
cond_br %arg0, cf.cond_br %arg0,
^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>), ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>) ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
^bb1(%1: memref<2xf32>, %2: memref<2xf32>): ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>) cf.br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>)
^bb2(%3: memref<2xf32>, %4: memref<2xf32>): ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>) cf.br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>)
^bb3(%5: memref<2xf32>, %6: memref<2xf32>): ^bb3(%5: memref<2xf32>, %6: memref<2xf32>):
test.copy(%arg1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%arg1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[FIRST_ALLOC:.*]] = memref.alloc() // CHECK-NEXT: %[[FIRST_ALLOC:.*]] = memref.alloc()
// CHECK: test.copy // CHECK: test.copy
// CHECK-NEXT: memref.dealloc %[[FIRST_ALLOC]] // CHECK-NEXT: memref.dealloc %[[FIRST_ALLOC]]
Show All 12 Lines
// bb5 <- Initial position of the second AllocOp // bb5 <- Initial position of the second AllocOp
// BufferDeallocation expected behavior: Two missing DeallocOps should be // BufferDeallocation expected behavior: Two missing DeallocOps should be
// inserted in the exit block. // inserted in the exit block.
// CHECK-LABEL: func @ifElseNested // CHECK-LABEL: func @ifElseNested
func @ifElseNested(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @ifElseNested(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
cond_br %arg0, cf.cond_br %arg0,
^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>), ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>) ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
^bb1(%1: memref<2xf32>, %2: memref<2xf32>): ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>) cf.br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>)
^bb2(%3: memref<2xf32>, %4: memref<2xf32>): ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>) cf.cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>)
^bb3(%5: memref<2xf32>): ^bb3(%5: memref<2xf32>):
br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>) cf.br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>)
^bb4(%6: memref<2xf32>): ^bb4(%6: memref<2xf32>):
br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>) cf.br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>)
^bb5(%7: memref<2xf32>, %8: memref<2xf32>): ^bb5(%7: memref<2xf32>, %8: memref<2xf32>):
%9 = memref.alloc() : memref<2xf32> %9 = memref.alloc() : memref<2xf32>
test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>) test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>)
test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[FIRST_ALLOC:.*]] = memref.alloc() // CHECK-NEXT: %[[FIRST_ALLOC:.*]] = memref.alloc()
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
// inserted in the respective block of the allocs. The copy is freed in the exit // inserted in the respective block of the allocs. The copy is freed in the exit
// block. // block.
// CHECK-LABEL: func @moving_alloc_and_inserting_missing_dealloc // CHECK-LABEL: func @moving_alloc_and_inserting_missing_dealloc
func @moving_alloc_and_inserting_missing_dealloc( func @moving_alloc_and_inserting_missing_dealloc(
%cond: i1, %cond: i1,
%arg0: memref<2xf32>, %arg0: memref<2xf32>,
%arg1: memref<2xf32>) { %arg1: memref<2xf32>) {
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>)
br ^exit(%0 : memref<2xf32>) cf.br ^exit(%0 : memref<2xf32>)
^bb2: ^bb2:
%1 = memref.alloc() : memref<2xf32> %1 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>) test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>)
br ^exit(%1 : memref<2xf32>) cf.br ^exit(%1 : memref<2xf32>)
^exit(%arg2: memref<2xf32>): ^exit(%arg2: memref<2xf32>):
test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>) test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: cond_br{{.*}} // CHECK-NEXT: cf.cond_br{{.*}}
// CHECK-NEXT: ^bb1 // CHECK-NEXT: ^bb1
// CHECK: %[[ALLOC0:.*]] = memref.alloc() // CHECK: %[[ALLOC0:.*]] = memref.alloc()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// CHECK-NEXT: %[[ALLOC1:.*]] = bufferization.clone %[[ALLOC0]] // CHECK-NEXT: %[[ALLOC1:.*]] = bufferization.clone %[[ALLOC0]]
// CHECK-NEXT: memref.dealloc %[[ALLOC0]] // CHECK-NEXT: memref.dealloc %[[ALLOC0]]
// CHECK-NEXT: br ^bb3(%[[ALLOC1]] // CHECK-NEXT: cf.br ^bb3(%[[ALLOC1]]
// CHECK-NEXT: ^bb2 // CHECK-NEXT: ^bb2
// CHECK-NEXT: %[[ALLOC2:.*]] = memref.alloc() // CHECK-NEXT: %[[ALLOC2:.*]] = memref.alloc()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// CHECK-NEXT: %[[ALLOC3:.*]] = bufferization.clone %[[ALLOC2]] // CHECK-NEXT: %[[ALLOC3:.*]] = bufferization.clone %[[ALLOC2]]
// CHECK-NEXT: memref.dealloc %[[ALLOC2]] // CHECK-NEXT: memref.dealloc %[[ALLOC2]]
// CHECK-NEXT: br ^bb3(%[[ALLOC3]] // CHECK-NEXT: cf.br ^bb3(%[[ALLOC3]]
// CHECK-NEXT: ^bb3(%[[ALLOC4:.*]]:{{.*}}) // CHECK-NEXT: ^bb3(%[[ALLOC4:.*]]:{{.*}})
// CHECK: test.copy // CHECK: test.copy
// CHECK-NEXT: memref.dealloc %[[ALLOC4]] // CHECK-NEXT: memref.dealloc %[[ALLOC4]]
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// Test Case: Invalid position of the DeallocOp. There is a user after // Test Case: Invalid position of the DeallocOp. There is a user after
// deallocation. // deallocation.
// bb0 // bb0
// / \ // / \
// bb1 bb2 <- Initial position of AllocOp // bb1 bb2 <- Initial position of AllocOp
// \ / // \ /
// bb3 // bb3
// BufferDeallocation expected behavior: The existing DeallocOp should be // BufferDeallocation expected behavior: The existing DeallocOp should be
// moved to exit block. // moved to exit block.
// CHECK-LABEL: func @moving_invalid_dealloc_op_complex // CHECK-LABEL: func @moving_invalid_dealloc_op_complex
func @moving_invalid_dealloc_op_complex( func @moving_invalid_dealloc_op_complex(
%cond: i1, %cond: i1,
%arg0: memref<2xf32>, %arg0: memref<2xf32>,
%arg1: memref<2xf32>) { %arg1: memref<2xf32>) {
%1 = memref.alloc() : memref<2xf32> %1 = memref.alloc() : memref<2xf32>
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
br ^exit(%arg0 : memref<2xf32>) cf.br ^exit(%arg0 : memref<2xf32>)
^bb2: ^bb2:
test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>) test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>)
memref.dealloc %1 : memref<2xf32> memref.dealloc %1 : memref<2xf32>
br ^exit(%1 : memref<2xf32>) cf.br ^exit(%1 : memref<2xf32>)
^exit(%arg2: memref<2xf32>): ^exit(%arg2: memref<2xf32>):
test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>) test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc() // CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK: test.copy // CHECK: test.copy
// CHECK-NEXT: memref.dealloc %[[ALLOC0]] // CHECK-NEXT: memref.dealloc %[[ALLOC0]]
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// Test Case: Inserting missing DeallocOp in a single block. // Test Case: Inserting missing DeallocOp in a single block.
Show All 38 Lines
// the missing DeallocOp in the same region. The missing DeallocOp should be // the missing DeallocOp in the same region. The missing DeallocOp should be
// inserted after CopyOp. // inserted after CopyOp.
// CHECK-LABEL: func @nested_regions_and_cond_branch // CHECK-LABEL: func @nested_regions_and_cond_branch
func @nested_regions_and_cond_branch( func @nested_regions_and_cond_branch(
%arg0: i1, %arg0: i1,
%arg1: memref<2xf32>, %arg1: memref<2xf32>,
%arg2: memref<2xf32>) { %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) { test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) {
^bb0(%gen1_arg0: f32, %gen1_arg1: f32): ^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
%1 = memref.alloc() : memref<2xf32> %1 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>)
%tmp1 = math.exp %gen1_arg0 : f32 %tmp1 = math.exp %gen1_arg0 : f32
test.region_yield %tmp1 : f32 test.region_yield %tmp1 : f32
} }
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK: (%[[cond:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %{{.*}}: {{.*}}) // CHECK: (%[[cond:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %{{.*}}: {{.*}})
// CHECK-NEXT: cond_br %[[cond]], ^[[BB1:.*]], ^[[BB2:.*]] // CHECK-NEXT: cf.cond_br %[[cond]], ^[[BB1:.*]], ^[[BB2:.*]]
// CHECK: %[[ALLOC0:.*]] = bufferization.clone %[[ARG1]] // CHECK: %[[ALLOC0:.*]] = bufferization.clone %[[ARG1]]
// CHECK: ^[[BB2]]: // CHECK: ^[[BB2]]:
// CHECK: %[[ALLOC1:.*]] = memref.alloc() // CHECK: %[[ALLOC1:.*]] = memref.alloc()
// CHECK-NEXT: test.region_buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOC1]] // CHECK-NEXT: test.region_buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOC1]]
// CHECK: %[[ALLOC2:.*]] = memref.alloc() // CHECK: %[[ALLOC2:.*]] = memref.alloc()
// CHECK-NEXT: test.buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOC2]] // CHECK-NEXT: test.buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOC2]]
// CHECK: memref.dealloc %[[ALLOC2]] // CHECK: memref.dealloc %[[ALLOC2]]
// CHECK-NEXT: %{{.*}} = math.exp // CHECK-NEXT: %{{.*}} = math.exp
▲ Show 20 Lines • Show All 145 Lines • ▼ Show 20 Lines
// ----- // -----
// Test Case: In the presence of AllocaOps only the AllocOps has top be freed. // Test Case: In the presence of AllocaOps only the AllocOps has top be freed.
// Therefore, all allocas are not handled. // Therefore, all allocas are not handled.
// CHECK-LABEL: func @condBranchAlloca // CHECK-LABEL: func @condBranchAlloca
func @condBranchAlloca(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @condBranchAlloca(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloca() : memref<2xf32> %0 = memref.alloca() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK: %[[ALLOCA:.*]] = memref.alloca() // CHECK: %[[ALLOCA:.*]] = memref.alloca()
// CHECK: br ^bb3(%[[ALLOCA:.*]]) // CHECK: cf.br ^bb3(%[[ALLOCA:.*]])
// CHECK-NEXT: ^bb3 // CHECK-NEXT: ^bb3
// CHECK-NEXT: test.copy // CHECK-NEXT: test.copy
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// Test Case: In the presence of AllocaOps only the AllocOps has top be freed. // Test Case: In the presence of AllocaOps only the AllocOps has top be freed.
// Therefore, all allocas are not handled. In this case, only alloc %0 has a // Therefore, all allocas are not handled. In this case, only alloc %0 has a
// dealloc. // dealloc.
// CHECK-LABEL: func @ifElseAlloca // CHECK-LABEL: func @ifElseAlloca
func @ifElseAlloca(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @ifElseAlloca(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
cond_br %arg0, cf.cond_br %arg0,
^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>), ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>) ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
^bb1(%1: memref<2xf32>, %2: memref<2xf32>): ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>) cf.br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>)
^bb2(%3: memref<2xf32>, %4: memref<2xf32>): ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>) cf.br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>)
^bb3(%5: memref<2xf32>, %6: memref<2xf32>): ^bb3(%5: memref<2xf32>, %6: memref<2xf32>):
%7 = memref.alloca() : memref<2xf32> %7 = memref.alloca() : memref<2xf32>
test.buffer_based in(%5: memref<2xf32>) out(%7: memref<2xf32>) test.buffer_based in(%5: memref<2xf32>) out(%7: memref<2xf32>)
test.copy(%7, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%7, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc() // CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// CHECK: %[[ALLOCA:.*]] = memref.alloca() // CHECK: %[[ALLOCA:.*]] = memref.alloca()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// CHECK: memref.dealloc %[[ALLOC]] // CHECK: memref.dealloc %[[ALLOC]]
// CHECK: test.copy // CHECK: test.copy
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// CHECK-LABEL: func @ifElseNestedAlloca // CHECK-LABEL: func @ifElseNestedAlloca
func @ifElseNestedAlloca( func @ifElseNestedAlloca(
%arg0: i1, %arg0: i1,
%arg1: memref<2xf32>, %arg1: memref<2xf32>,
%arg2: memref<2xf32>) { %arg2: memref<2xf32>) {
%0 = memref.alloca() : memref<2xf32> %0 = memref.alloca() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
cond_br %arg0, cf.cond_br %arg0,
^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>), ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>) ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
^bb1(%1: memref<2xf32>, %2: memref<2xf32>): ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>) cf.br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>)
^bb2(%3: memref<2xf32>, %4: memref<2xf32>): ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>) cf.cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>)
^bb3(%5: memref<2xf32>): ^bb3(%5: memref<2xf32>):
br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>) cf.br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>)
^bb4(%6: memref<2xf32>): ^bb4(%6: memref<2xf32>):
br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>) cf.br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>)
^bb5(%7: memref<2xf32>, %8: memref<2xf32>): ^bb5(%7: memref<2xf32>, %8: memref<2xf32>):
%9 = memref.alloc() : memref<2xf32> %9 = memref.alloc() : memref<2xf32>
test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>) test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>)
test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca() // CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// CHECK: %[[ALLOC:.*]] = memref.alloc() // CHECK: %[[ALLOC:.*]] = memref.alloc()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// CHECK: test.copy // CHECK: test.copy
// CHECK-NEXT: memref.dealloc %[[ALLOC]] // CHECK-NEXT: memref.dealloc %[[ALLOC]]
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// CHECK-LABEL: func @nestedRegionsAndCondBranchAlloca // CHECK-LABEL: func @nestedRegionsAndCondBranchAlloca
func @nestedRegionsAndCondBranchAlloca( func @nestedRegionsAndCondBranchAlloca(
%arg0: i1, %arg0: i1,
%arg1: memref<2xf32>, %arg1: memref<2xf32>,
%arg2: memref<2xf32>) { %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) { test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) {
^bb0(%gen1_arg0: f32, %gen1_arg1: f32): ^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
%1 = memref.alloca() : memref<2xf32> %1 = memref.alloca() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>)
%tmp1 = math.exp %gen1_arg0 : f32 %tmp1 = math.exp %gen1_arg0 : f32
test.region_yield %tmp1 : f32 test.region_yield %tmp1 : f32
} }
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK: (%[[cond:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %{{.*}}: {{.*}}) // CHECK: (%[[cond:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %{{.*}}: {{.*}})
// CHECK-NEXT: cond_br %[[cond]], ^[[BB1:.*]], ^[[BB2:.*]] // CHECK-NEXT: cf.cond_br %[[cond]], ^[[BB1:.*]], ^[[BB2:.*]]
// CHECK: ^[[BB1]]: // CHECK: ^[[BB1]]:
// CHECK: %[[ALLOC0:.*]] = bufferization.clone // CHECK: %[[ALLOC0:.*]] = bufferization.clone
// CHECK: ^[[BB2]]: // CHECK: ^[[BB2]]:
// CHECK: %[[ALLOC1:.*]] = memref.alloc() // CHECK: %[[ALLOC1:.*]] = memref.alloc()
// CHECK-NEXT: test.region_buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOC1]] // CHECK-NEXT: test.region_buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOC1]]
// CHECK: %[[ALLOCA:.*]] = memref.alloca() // CHECK: %[[ALLOCA:.*]] = memref.alloca()
// CHECK-NEXT: test.buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOCA]] // CHECK-NEXT: test.buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOCA]]
// CHECK: %{{.*}} = math.exp // CHECK: %{{.*}} = math.exp
▲ Show 20 Lines • Show All 247 Lines • ▼ Show 20 Lines
// expected-error@+1 {{Only structured control-flow loops are supported}} // expected-error@+1 {{Only structured control-flow loops are supported}}
func @loop_dynalloc( func @loop_dynalloc(
%arg0 : i32, %arg0 : i32,
%arg1 : i32, %arg1 : i32,
%arg2: memref<?xf32>, %arg2: memref<?xf32>,
%arg3: memref<?xf32>) { %arg3: memref<?xf32>) {
%const0 = arith.constant 0 : i32 %const0 = arith.constant 0 : i32
br ^loopHeader(%const0, %arg2 : i32, memref<?xf32>) cf.br ^loopHeader(%const0, %arg2 : i32, memref<?xf32>)
^loopHeader(%i : i32, %buff : memref<?xf32>): ^loopHeader(%i : i32, %buff : memref<?xf32>):
%lessThan = arith.cmpi slt, %i, %arg1 : i32 %lessThan = arith.cmpi slt, %i, %arg1 : i32
cond_br %lessThan, cf.cond_br %lessThan,
^loopBody(%i, %buff : i32, memref<?xf32>), ^loopBody(%i, %buff : i32, memref<?xf32>),
^exit(%buff : memref<?xf32>) ^exit(%buff : memref<?xf32>)
^loopBody(%val : i32, %buff2: memref<?xf32>): ^loopBody(%val : i32, %buff2: memref<?xf32>):
%const1 = arith.constant 1 : i32 %const1 = arith.constant 1 : i32
%inc = arith.addi %val, %const1 : i32 %inc = arith.addi %val, %const1 : i32
%size = arith.index_cast %inc : i32 to index %size = arith.index_cast %inc : i32 to index
%alloc1 = memref.alloc(%size) : memref<?xf32> %alloc1 = memref.alloc(%size) : memref<?xf32>
br ^loopHeader(%inc, %alloc1 : i32, memref<?xf32>) cf.br ^loopHeader(%inc, %alloc1 : i32, memref<?xf32>)
^exit(%buff3 : memref<?xf32>): ^exit(%buff3 : memref<?xf32>):
test.copy(%buff3, %arg3) : (memref<?xf32>, memref<?xf32>) test.copy(%buff3, %arg3) : (memref<?xf32>, memref<?xf32>)
return return
} }
// ----- // -----
// Test Case: explicit control-flow loop with a dynamically allocated buffer. // Test Case: explicit control-flow loop with a dynamically allocated buffer.
// The BufferDeallocation transformation should fail on this explicit // The BufferDeallocation transformation should fail on this explicit
// control-flow loop since they are not supported. // control-flow loop since they are not supported.
// expected-error@+1 {{Only structured control-flow loops are supported}} // expected-error@+1 {{Only structured control-flow loops are supported}}
func @do_loop_alloc( func @do_loop_alloc(
%arg0 : i32, %arg0 : i32,
%arg1 : i32, %arg1 : i32,
%arg2: memref<2xf32>, %arg2: memref<2xf32>,
%arg3: memref<2xf32>) { %arg3: memref<2xf32>) {
%const0 = arith.constant 0 : i32 %const0 = arith.constant 0 : i32
br ^loopBody(%const0, %arg2 : i32, memref<2xf32>) cf.br ^loopBody(%const0, %arg2 : i32, memref<2xf32>)
^loopBody(%val : i32, %buff2: memref<2xf32>): ^loopBody(%val : i32, %buff2: memref<2xf32>):
%const1 = arith.constant 1 : i32 %const1 = arith.constant 1 : i32
%inc = arith.addi %val, %const1 : i32 %inc = arith.addi %val, %const1 : i32
%alloc1 = memref.alloc() : memref<2xf32> %alloc1 = memref.alloc() : memref<2xf32>
br ^loopHeader(%inc, %alloc1 : i32, memref<2xf32>) cf.br ^loopHeader(%inc, %alloc1 : i32, memref<2xf32>)
^loopHeader(%i : i32, %buff : memref<2xf32>): ^loopHeader(%i : i32, %buff : memref<2xf32>):
%lessThan = arith.cmpi slt, %i, %arg1 : i32 %lessThan = arith.cmpi slt, %i, %arg1 : i32
cond_br %lessThan, cf.cond_br %lessThan,
^loopBody(%i, %buff : i32, memref<2xf32>), ^loopBody(%i, %buff : i32, memref<2xf32>),
^exit(%buff : memref<2xf32>) ^exit(%buff : memref<2xf32>)
^exit(%buff3 : memref<2xf32>): ^exit(%buff3 : memref<2xf32>):
test.copy(%buff3, %arg3) : (memref<2xf32>, memref<2xf32>) test.copy(%buff3, %arg3) : (memref<2xf32>, memref<2xf32>)
return return
} }
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

mlir/test/Dialect/ControlFlow/canonicalize.mlir

  • This file was moved from mlir/test/Dialect/Standard/canonicalize-cf.mlir.
// RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline='builtin.func(canonicalize)' -split-input-file | FileCheck --dump-input-context 20 %s // RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline='builtin.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 @br_folding() -> i32 { 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
br ^bb1(%c0_i32 : i32) cf.br ^bb1(%c0_i32 : i32)
^bb1(%x : i32): ^bb1(%x : i32):
return %x : i32 return %x : i32
} }
/// Test that pass-through successors of BranchOp get folded. /// Test that pass-through successors of BranchOp get folded.
// CHECK-LABEL: func @br_passthrough( // CHECK-LABEL: func @br_passthrough(
// CHECK-SAME: %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32 // CHECK-SAME: %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32
func @br_passthrough(%arg0 : i32, %arg1 : i32) -> (i32, i32) { func @br_passthrough(%arg0 : i32, %arg1 : i32) -> (i32, i32) {
"foo.switch"() [^bb1, ^bb2, ^bb3] : () -> () "foo.switch"() [^bb1, ^bb2, ^bb3] : () -> ()
^bb1: ^bb1:
// CHECK: ^bb1: // CHECK: ^bb1:
// CHECK-NEXT: br ^bb3(%[[ARG0]], %[[ARG1]] : i32, i32) // CHECK-NEXT: cf.br ^bb3(%[[ARG0]], %[[ARG1]] : i32, i32)
br ^bb2(%arg0 : i32) cf.br ^bb2(%arg0 : i32)
^bb2(%arg2 : i32): ^bb2(%arg2 : i32):
br ^bb3(%arg2, %arg1 : i32, i32) cf.br ^bb3(%arg2, %arg1 : i32, i32)
^bb3(%arg4 : i32, %arg5 : i32): ^bb3(%arg4 : i32, %arg5 : i32):
return %arg4, %arg5 : i32, i32 return %arg4, %arg5 : i32, i32
} }
/// Test the folding of CondBranchOp with a constant condition. /// Test the folding of CondBranchOp with a constant condition.
// CHECK-LABEL: func @cond_br_folding( // CHECK-LABEL: func @cond_br_folding(
func @cond_br_folding(%cond : i1, %a : i32) { func @cond_br_folding(%cond : i1, %a : i32) {
// CHECK-NEXT: return // CHECK-NEXT: return
%false_cond = arith.constant false %false_cond = arith.constant false
%true_cond = arith.constant true %true_cond = arith.constant true
cond_br %cond, ^bb1, ^bb2(%a : i32) cf.cond_br %cond, ^bb1, ^bb2(%a : i32)
^bb1: ^bb1:
cond_br %true_cond, ^bb3, ^bb2(%a : i32) cf.cond_br %true_cond, ^bb3, ^bb2(%a : i32)
^bb2(%x : i32): ^bb2(%x : i32):
cond_br %false_cond, ^bb2(%x : i32), ^bb3 cf.cond_br %false_cond, ^bb2(%x : i32), ^bb3
^bb3: ^bb3:
return return
} }
/// Test the folding of CondBranchOp when the successors are identical. /// Test the folding of CondBranchOp when the successors are identical.
// CHECK-LABEL: func @cond_br_same_successor( // CHECK-LABEL: func @cond_br_same_successor(
func @cond_br_same_successor(%cond : i1, %a : i32) { func @cond_br_same_successor(%cond : i1, %a : i32) {
// CHECK-NEXT: return // CHECK-NEXT: return
cond_br %cond, ^bb1(%a : i32), ^bb1(%a : i32) cf.cond_br %cond, ^bb1(%a : i32), ^bb1(%a : i32)
^bb1(%result : i32): ^bb1(%result : i32):
return return
} }
/// Test the folding of CondBranchOp when the successors are identical, but the /// Test the folding of CondBranchOp when the successors are identical, but the
/// arguments are different. /// arguments are different.
// CHECK-LABEL: func @cond_br_same_successor_insert_select( // CHECK-LABEL: func @cond_br_same_successor_insert_select(
// CHECK-SAME: %[[COND:.*]]: i1, %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32 // CHECK-SAME: %[[COND:.*]]: i1, %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32
// CHECK-SAME: %[[ARG2:.*]]: tensor<2xi32>, %[[ARG3:.*]]: tensor<2xi32> // CHECK-SAME: %[[ARG2:.*]]: tensor<2xi32>, %[[ARG3:.*]]: tensor<2xi32>
func @cond_br_same_successor_insert_select( func @cond_br_same_successor_insert_select(
%cond : i1, %a : i32, %b : i32, %c : tensor<2xi32>, %d : tensor<2xi32> %cond : i1, %a : i32, %b : i32, %c : tensor<2xi32>, %d : tensor<2xi32>
) -> (i32, tensor<2xi32>) { ) -> (i32, tensor<2xi32>) {
// CHECK: %[[RES:.*]] = arith.select %[[COND]], %[[ARG0]], %[[ARG1]] // CHECK: %[[RES:.*]] = arith.select %[[COND]], %[[ARG0]], %[[ARG1]]
// CHECK: %[[RES2:.*]] = arith.select %[[COND]], %[[ARG2]], %[[ARG3]] // CHECK: %[[RES2:.*]] = arith.select %[[COND]], %[[ARG2]], %[[ARG3]]
// CHECK: return %[[RES]], %[[RES2]] // CHECK: return %[[RES]], %[[RES2]]
cond_br %cond, ^bb1(%a, %c : i32, tensor<2xi32>), ^bb1(%b, %d : i32, tensor<2xi32>) cf.cond_br %cond, ^bb1(%a, %c : i32, tensor<2xi32>), ^bb1(%b, %d : i32, tensor<2xi32>)
^bb1(%result : i32, %result2 : tensor<2xi32>): ^bb1(%result : i32, %result2 : tensor<2xi32>):
return %result, %result2 : i32, tensor<2xi32> return %result, %result2 : i32, tensor<2xi32>
} }
/// Test the compound folding of BranchOp and CondBranchOp. /// Test the compound folding of BranchOp and CondBranchOp.
// CHECK-LABEL: func @cond_br_and_br_folding( // CHECK-LABEL: func @cond_br_and_br_folding(
func @cond_br_and_br_folding(%a : i32) { func @cond_br_and_br_folding(%a : i32) {
// CHECK-NEXT: return // CHECK-NEXT: return
%false_cond = arith.constant false %false_cond = arith.constant false
%true_cond = arith.constant true %true_cond = arith.constant true
cond_br %true_cond, ^bb2, ^bb1(%a : i32) cf.cond_br %true_cond, ^bb2, ^bb1(%a : i32)
^bb1(%x : i32): ^bb1(%x : i32):
cond_br %false_cond, ^bb1(%x : i32), ^bb2 cf.cond_br %false_cond, ^bb1(%x : i32), ^bb2
^bb2: ^bb2:
return return
} }
/// Test that pass-through successors of CondBranchOp get folded. /// Test that pass-through successors of CondBranchOp get folded.
// CHECK-LABEL: func @cond_br_passthrough( // CHECK-LABEL: func @cond_br_passthrough(
// CHECK-SAME: %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32, %[[ARG2:.*]]: i32, %[[COND:.*]]: i1 // CHECK-SAME: %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32, %[[ARG2:.*]]: i32, %[[COND:.*]]: i1
func @cond_br_passthrough(%arg0 : i32, %arg1 : i32, %arg2 : i32, %cond : i1) -> (i32, i32) { func @cond_br_passthrough(%arg0 : i32, %arg1 : i32, %arg2 : i32, %cond : i1) -> (i32, i32) {
// CHECK: %[[RES:.*]] = arith.select %[[COND]], %[[ARG0]], %[[ARG2]] // CHECK: %[[RES:.*]] = arith.select %[[COND]], %[[ARG0]], %[[ARG2]]
// CHECK: %[[RES2:.*]] = arith.select %[[COND]], %[[ARG1]], %[[ARG2]] // CHECK: %[[RES2:.*]] = arith.select %[[COND]], %[[ARG1]], %[[ARG2]]
// CHECK: return %[[RES]], %[[RES2]] // CHECK: return %[[RES]], %[[RES2]]
cond_br %cond, ^bb1(%arg0 : i32), ^bb2(%arg2, %arg2 : i32, i32) cf.cond_br %cond, ^bb1(%arg0 : i32), ^bb2(%arg2, %arg2 : i32, i32)
^bb1(%arg3: i32): ^bb1(%arg3: i32):
br ^bb2(%arg3, %arg1 : i32, i32) cf.br ^bb2(%arg3, %arg1 : i32, i32)
^bb2(%arg4: i32, %arg5: i32): ^bb2(%arg4: i32, %arg5: i32):
return %arg4, %arg5 : i32, i32 return %arg4, %arg5 : i32, i32
} }
/// Test the failure modes of collapsing CondBranchOp pass-throughs successors. /// Test the failure modes of collapsing CondBranchOp pass-throughs successors.
// CHECK-LABEL: func @cond_br_pass_through_fail( // CHECK-LABEL: func @cond_br_pass_through_fail(
func @cond_br_pass_through_fail(%cond : i1) { func @cond_br_pass_through_fail(%cond : i1) {
// CHECK: cond_br %{{.*}}, ^bb1, ^bb2 // CHECK: cf.cond_br %{{.*}}, ^bb1, ^bb2
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
// CHECK: ^bb1: // CHECK: ^bb1:
// CHECK: "foo.op" // CHECK: "foo.op"
// CHECK: br ^bb2 // CHECK: cf.br ^bb2
// Successors can't be collapsed if they contain other operations. // Successors can't be collapsed if they contain other operations.
"foo.op"() : () -> () "foo.op"() : () -> ()
br ^bb2 cf.br ^bb2
^bb2: ^bb2:
return return
} }
/// Test the folding of SwitchOp /// Test the folding of SwitchOp
// CHECK-LABEL: func @switch_only_default( // CHECK-LABEL: func @switch_only_default(
// CHECK-SAME: %[[FLAG:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[FLAG:[a-zA-Z0-9_]+]]
// CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]]
func @switch_only_default(%flag : i32, %caseOperand0 : f32) { func @switch_only_default(%flag : i32, %caseOperand0 : f32) {
// add predecessors for all blocks to avoid other canonicalizations. // add predecessors for all blocks to avoid other canonicalizations.
"foo.pred"() [^bb1, ^bb2] : () -> () "foo.pred"() [^bb1, ^bb2] : () -> ()
^bb1: ^bb1:
// CHECK-NOT: switch // CHECK-NOT: cf.switch
// CHECK: br ^[[BB2:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_0]] // CHECK: cf.br ^[[BB2:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_0]]
switch %flag : i32, [ cf.switch %flag : i32, [
default: ^bb2(%caseOperand0 : f32) default: ^bb2(%caseOperand0 : f32)
] ]
// CHECK: ^[[BB2]]({{.*}}): // CHECK: ^[[BB2]]({{.*}}):
^bb2(%bb2Arg : f32): ^bb2(%bb2Arg : f32):
// CHECK-NEXT: "foo.bb2Terminator" // CHECK-NEXT: "foo.bb2Terminator"
"foo.bb2Terminator"(%bb2Arg) : (f32) -> () "foo.bb2Terminator"(%bb2Arg) : (f32) -> ()
} }
// CHECK-LABEL: func @switch_case_matching_default( // CHECK-LABEL: func @switch_case_matching_default(
// CHECK-SAME: %[[FLAG:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[FLAG:[a-zA-Z0-9_]+]]
// CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]]
// CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]]
func @switch_case_matching_default(%flag : i32, %caseOperand0 : f32, %caseOperand1 : f32) { func @switch_case_matching_default(%flag : i32, %caseOperand0 : f32, %caseOperand1 : f32) {
// add predecessors for all blocks to avoid other canonicalizations. // add predecessors for all blocks to avoid other canonicalizations.
"foo.pred"() [^bb1, ^bb2, ^bb3] : () -> () "foo.pred"() [^bb1, ^bb2, ^bb3] : () -> ()
^bb1: ^bb1:
// CHECK: switch %[[FLAG]] // CHECK: cf.switch %[[FLAG]]
// CHECK-NEXT: default: ^[[BB1:.+]](%[[CASE_OPERAND_0]] : f32) // CHECK-NEXT: default: ^[[BB1:.+]](%[[CASE_OPERAND_0]] : f32)
// CHECK-NEXT: 10: ^[[BB2:.+]](%[[CASE_OPERAND_1]] : f32) // CHECK-NEXT: 10: ^[[BB2:.+]](%[[CASE_OPERAND_1]] : f32)
// CHECK-NEXT: ] // CHECK-NEXT: ]
switch %flag : i32, [ cf.switch %flag : i32, [
default: ^bb2(%caseOperand0 : f32), default: ^bb2(%caseOperand0 : f32),
42: ^bb2(%caseOperand0 : f32), 42: ^bb2(%caseOperand0 : f32),
10: ^bb3(%caseOperand1 : f32), 10: ^bb3(%caseOperand1 : f32),
17: ^bb2(%caseOperand0 : f32) 17: ^bb2(%caseOperand0 : f32)
] ]
^bb2(%bb2Arg : f32): ^bb2(%bb2Arg : f32):
"foo.bb2Terminator"(%bb2Arg) : (f32) -> () "foo.bb2Terminator"(%bb2Arg) : (f32) -> ()
^bb3(%bb3Arg : f32): ^bb3(%bb3Arg : f32):
"foo.bb3Terminator"(%bb3Arg) : (f32) -> () "foo.bb3Terminator"(%bb3Arg) : (f32) -> ()
} }
// CHECK-LABEL: func @switch_on_const_no_match( // CHECK-LABEL: func @switch_on_const_no_match(
// CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]]
// CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]]
// CHECK-SAME: %[[CASE_OPERAND_2:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_2:[a-zA-Z0-9_]+]]
func @switch_on_const_no_match(%caseOperand0 : f32, %caseOperand1 : f32, %caseOperand2 : f32) { func @switch_on_const_no_match(%caseOperand0 : f32, %caseOperand1 : f32, %caseOperand2 : f32) {
// add predecessors for all blocks to avoid other canonicalizations. // add predecessors for all blocks to avoid other canonicalizations.
"foo.pred"() [^bb1, ^bb2, ^bb3, ^bb4] : () -> () "foo.pred"() [^bb1, ^bb2, ^bb3, ^bb4] : () -> ()
^bb1: ^bb1:
// CHECK-NOT: switch // CHECK-NOT: cf.switch
// CHECK: br ^[[BB2:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_0]] // CHECK: cf.br ^[[BB2:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_0]]
%c0_i32 = arith.constant 0 : i32 %c0_i32 = arith.constant 0 : i32
switch %c0_i32 : i32, [ cf.switch %c0_i32 : i32, [
default: ^bb2(%caseOperand0 : f32), default: ^bb2(%caseOperand0 : f32),
-1: ^bb3(%caseOperand1 : f32), -1: ^bb3(%caseOperand1 : f32),
1: ^bb4(%caseOperand2 : f32) 1: ^bb4(%caseOperand2 : f32)
] ]
// CHECK: ^[[BB2]]({{.*}}): // CHECK: ^[[BB2]]({{.*}}):
// CHECK-NEXT: "foo.bb2Terminator" // CHECK-NEXT: "foo.bb2Terminator"
^bb2(%bb2Arg : f32): ^bb2(%bb2Arg : f32):
"foo.bb2Terminator"(%bb2Arg) : (f32) -> () "foo.bb2Terminator"(%bb2Arg) : (f32) -> ()
^bb3(%bb3Arg : f32): ^bb3(%bb3Arg : f32):
"foo.bb3Terminator"(%bb3Arg) : (f32) -> () "foo.bb3Terminator"(%bb3Arg) : (f32) -> ()
^bb4(%bb4Arg : f32): ^bb4(%bb4Arg : f32):
"foo.bb4Terminator"(%bb4Arg) : (f32) -> () "foo.bb4Terminator"(%bb4Arg) : (f32) -> ()
} }
// CHECK-LABEL: func @switch_on_const_with_match( // CHECK-LABEL: func @switch_on_const_with_match(
// CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]]
// CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]]
// CHECK-SAME: %[[CASE_OPERAND_2:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_2:[a-zA-Z0-9_]+]]
func @switch_on_const_with_match(%caseOperand0 : f32, %caseOperand1 : f32, %caseOperand2 : f32) { func @switch_on_const_with_match(%caseOperand0 : f32, %caseOperand1 : f32, %caseOperand2 : f32) {
// add predecessors for all blocks to avoid other canonicalizations. // add predecessors for all blocks to avoid other canonicalizations.
"foo.pred"() [^bb1, ^bb2, ^bb3, ^bb4] : () -> () "foo.pred"() [^bb1, ^bb2, ^bb3, ^bb4] : () -> ()
^bb1: ^bb1:
// CHECK-NOT: switch // CHECK-NOT: cf.switch
// CHECK: br ^[[BB4:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_2]] // CHECK: cf.br ^[[BB4:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_2]]
%c0_i32 = arith.constant 1 : i32 %c0_i32 = arith.constant 1 : i32
switch %c0_i32 : i32, [ cf.switch %c0_i32 : i32, [
default: ^bb2(%caseOperand0 : f32), default: ^bb2(%caseOperand0 : f32),
-1: ^bb3(%caseOperand1 : f32), -1: ^bb3(%caseOperand1 : f32),
1: ^bb4(%caseOperand2 : f32) 1: ^bb4(%caseOperand2 : f32)
] ]
^bb2(%bb2Arg : f32): ^bb2(%bb2Arg : f32):
"foo.bb2Terminator"(%bb2Arg) : (f32) -> () "foo.bb2Terminator"(%bb2Arg) : (f32) -> ()
^bb3(%bb3Arg : f32): ^bb3(%bb3Arg : f32):
"foo.bb3Terminator"(%bb3Arg) : (f32) -> () "foo.bb3Terminator"(%bb3Arg) : (f32) -> ()
Show All 13 Linesfunc @switch_passthrough(%flag : i32,
%caseOperand0 : f32, %caseOperand0 : f32,
%caseOperand1 : f32, %caseOperand1 : f32,
%caseOperand2 : f32, %caseOperand2 : f32,
%caseOperand3 : f32) { %caseOperand3 : f32) {
// add predecessors for all blocks to avoid other canonicalizations. // add predecessors for all blocks to avoid other canonicalizations.
"foo.pred"() [^bb1, ^bb2, ^bb3, ^bb4, ^bb5, ^bb6] : () -> () "foo.pred"() [^bb1, ^bb2, ^bb3, ^bb4, ^bb5, ^bb6] : () -> ()
^bb1: ^bb1:
// CHECK: switch %[[FLAG]] // CHECK: cf.switch %[[FLAG]]
// CHECK-NEXT: default: ^[[BB5:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_0]] // CHECK-NEXT: default: ^[[BB5:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_0]]
// CHECK-NEXT: 43: ^[[BB6:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_1]] // CHECK-NEXT: 43: ^[[BB6:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_1]]
// CHECK-NEXT: 44: ^[[BB4:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_2]] // CHECK-NEXT: 44: ^[[BB4:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_2]]
// CHECK-NEXT: ] // CHECK-NEXT: ]
switch %flag : i32, [ cf.switch %flag : i32, [
default: ^bb2(%caseOperand0 : f32), default: ^bb2(%caseOperand0 : f32),
43: ^bb3(%caseOperand1 : f32), 43: ^bb3(%caseOperand1 : f32),
44: ^bb4(%caseOperand2 : f32) 44: ^bb4(%caseOperand2 : f32)
] ]
^bb2(%bb2Arg : f32): ^bb2(%bb2Arg : f32):
br ^bb5(%bb2Arg : f32) cf.br ^bb5(%bb2Arg : f32)
^bb3(%bb3Arg : f32): ^bb3(%bb3Arg : f32):
br ^bb6(%bb3Arg : f32) cf.br ^bb6(%bb3Arg : f32)
^bb4(%bb4Arg : f32): ^bb4(%bb4Arg : f32):
"foo.bb4Terminator"(%bb4Arg) : (f32) -> () "foo.bb4Terminator"(%bb4Arg) : (f32) -> ()
// CHECK: ^[[BB5]]({{.*}}): // CHECK: ^[[BB5]]({{.*}}):
// CHECK-NEXT: "foo.bb5Terminator" // CHECK-NEXT: "foo.bb5Terminator"
^bb5(%bb5Arg : f32): ^bb5(%bb5Arg : f32):
"foo.bb5Terminator"(%bb5Arg) : (f32) -> () "foo.bb5Terminator"(%bb5Arg) : (f32) -> ()
// CHECK: ^[[BB6]]({{.*}}): // CHECK: ^[[BB6]]({{.*}}):
// CHECK-NEXT: "foo.bb6Terminator" // CHECK-NEXT: "foo.bb6Terminator"
^bb6(%bb6Arg : f32): ^bb6(%bb6Arg : f32):
"foo.bb6Terminator"(%bb6Arg) : (f32) -> () "foo.bb6Terminator"(%bb6Arg) : (f32) -> ()
} }
// CHECK-LABEL: func @switch_from_switch_with_same_value_with_match( // CHECK-LABEL: func @switch_from_switch_with_same_value_with_match(
// CHECK-SAME: %[[FLAG:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[FLAG:[a-zA-Z0-9_]+]]
// CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]]
// CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]]
func @switch_from_switch_with_same_value_with_match(%flag : i32, %caseOperand0 : f32, %caseOperand1 : f32) { func @switch_from_switch_with_same_value_with_match(%flag : i32, %caseOperand0 : f32, %caseOperand1 : f32) {
// add predecessors for all blocks except ^bb3 to avoid other canonicalizations. // add predecessors for all blocks except ^bb3 to avoid other canonicalizations.
"foo.pred"() [^bb1, ^bb2, ^bb4, ^bb5] : () -> () "foo.pred"() [^bb1, ^bb2, ^bb4, ^bb5] : () -> ()
^bb1: ^bb1:
// CHECK: switch %[[FLAG]] // CHECK: cf.switch %[[FLAG]]
switch %flag : i32, [ cf.switch %flag : i32, [
default: ^bb2, default: ^bb2,
42: ^bb3 42: ^bb3
] ]
^bb2: ^bb2:
"foo.bb2Terminator"() : () -> () "foo.bb2Terminator"() : () -> ()
^bb3: ^bb3:
// prevent this block from being simplified away // prevent this block from being simplified away
"foo.op"() : () -> () "foo.op"() : () -> ()
// CHECK-NOT: switch %[[FLAG]] // CHECK-NOT: cf.switch %[[FLAG]]
// CHECK: br ^[[BB5:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_1]] // CHECK: cf.br ^[[BB5:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_1]]
switch %flag : i32, [ cf.switch %flag : i32, [
default: ^bb4(%caseOperand0 : f32), default: ^bb4(%caseOperand0 : f32),
42: ^bb5(%caseOperand1 : f32) 42: ^bb5(%caseOperand1 : f32)
] ]
^bb4(%bb4Arg : f32): ^bb4(%bb4Arg : f32):
"foo.bb4Terminator"(%bb4Arg) : (f32) -> () "foo.bb4Terminator"(%bb4Arg) : (f32) -> ()
// CHECK: ^[[BB5]]({{.*}}): // CHECK: ^[[BB5]]({{.*}}):
// CHECK-NEXT: "foo.bb5Terminator" // CHECK-NEXT: "foo.bb5Terminator"
^bb5(%bb5Arg : f32): ^bb5(%bb5Arg : f32):
"foo.bb5Terminator"(%bb5Arg) : (f32) -> () "foo.bb5Terminator"(%bb5Arg) : (f32) -> ()
} }
// CHECK-LABEL: func @switch_from_switch_with_same_value_no_match( // CHECK-LABEL: func @switch_from_switch_with_same_value_no_match(
// CHECK-SAME: %[[FLAG:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[FLAG:[a-zA-Z0-9_]+]]
// CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]]
// CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]]
// CHECK-SAME: %[[CASE_OPERAND_2:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_2:[a-zA-Z0-9_]+]]
func @switch_from_switch_with_same_value_no_match(%flag : i32, %caseOperand0 : f32, %caseOperand1 : f32, %caseOperand2 : f32) { func @switch_from_switch_with_same_value_no_match(%flag : i32, %caseOperand0 : f32, %caseOperand1 : f32, %caseOperand2 : f32) {
// add predecessors for all blocks except ^bb3 to avoid other canonicalizations. // add predecessors for all blocks except ^bb3 to avoid other canonicalizations.
"foo.pred"() [^bb1, ^bb2, ^bb4, ^bb5, ^bb6] : () -> () "foo.pred"() [^bb1, ^bb2, ^bb4, ^bb5, ^bb6] : () -> ()
^bb1: ^bb1:
// CHECK: switch %[[FLAG]] // CHECK: cf.switch %[[FLAG]]
switch %flag : i32, [ cf.switch %flag : i32, [
default: ^bb2, default: ^bb2,
42: ^bb3 42: ^bb3
] ]
^bb2: ^bb2:
"foo.bb2Terminator"() : () -> () "foo.bb2Terminator"() : () -> ()
^bb3: ^bb3:
"foo.op"() : () -> () "foo.op"() : () -> ()
// CHECK-NOT: switch %[[FLAG]] // CHECK-NOT: cf.switch %[[FLAG]]
// CHECK: br ^[[BB4:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_0]] // CHECK: cf.br ^[[BB4:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_0]]
switch %flag : i32, [ cf.switch %flag : i32, [
default: ^bb4(%caseOperand0 : f32), default: ^bb4(%caseOperand0 : f32),
0: ^bb5(%caseOperand1 : f32), 0: ^bb5(%caseOperand1 : f32),
43: ^bb6(%caseOperand2 : f32) 43: ^bb6(%caseOperand2 : f32)
] ]
// CHECK: ^[[BB4]]({{.*}}) // CHECK: ^[[BB4]]({{.*}})
// CHECK-NEXT: "foo.bb4Terminator" // CHECK-NEXT: "foo.bb4Terminator"
^bb4(%bb4Arg : f32): ^bb4(%bb4Arg : f32):
Show All 11 Lines
// CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_0:[a-zA-Z0-9_]+]]
// CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_1:[a-zA-Z0-9_]+]]
// CHECK-SAME: %[[CASE_OPERAND_2:[a-zA-Z0-9_]+]] // CHECK-SAME: %[[CASE_OPERAND_2:[a-zA-Z0-9_]+]]
func @switch_from_switch_default_with_same_value(%flag : i32, %caseOperand0 : f32, %caseOperand1 : f32, %caseOperand2 : f32) { func @switch_from_switch_default_with_same_value(%flag : i32, %caseOperand0 : f32, %caseOperand1 : f32, %caseOperand2 : f32) {
// add predecessors for all blocks except ^bb3 to avoid other canonicalizations. // add predecessors for all blocks except ^bb3 to avoid other canonicalizations.
"foo.pred"() [^bb1, ^bb2, ^bb4, ^bb5, ^bb6] : () -> () "foo.pred"() [^bb1, ^bb2, ^bb4, ^bb5, ^bb6] : () -> ()
^bb1: ^bb1:
// CHECK: switch %[[FLAG]] // CHECK: cf.switch %[[FLAG]]
switch %flag : i32, [ cf.switch %flag : i32, [
default: ^bb3, default: ^bb3,
42: ^bb2 42: ^bb2
] ]
^bb2: ^bb2:
"foo.bb2Terminator"() : () -> () "foo.bb2Terminator"() : () -> ()
^bb3: ^bb3:
"foo.op"() : () -> () "foo.op"() : () -> ()
// CHECK: switch %[[FLAG]] // CHECK: cf.switch %[[FLAG]]
// CHECK-NEXT: default: ^[[BB4:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_0]] // CHECK-NEXT: default: ^[[BB4:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_0]]
// CHECK-NEXT: 43: ^[[BB6:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_2]] // CHECK-NEXT: 43: ^[[BB6:[a-zA-Z0-9_]+]](%[[CASE_OPERAND_2]]
// CHECK-NOT: 42 // CHECK-NOT: 42
switch %flag : i32, [ cf.switch %flag : i32, [
default: ^bb4(%caseOperand0 : f32), default: ^bb4(%caseOperand0 : f32),
42: ^bb5(%caseOperand1 : f32), 42: ^bb5(%caseOperand1 : f32),
43: ^bb6(%caseOperand2 : f32) 43: ^bb6(%caseOperand2 : f32)
] ]
// CHECK: ^[[BB4]]({{.*}}): // CHECK: ^[[BB4]]({{.*}}):
// CHECK-NEXT: "foo.bb4Terminator" // CHECK-NEXT: "foo.bb4Terminator"
^bb4(%bb4Arg : f32): ^bb4(%bb4Arg : f32):
"foo.bb4Terminator"(%bb4Arg) : (f32) -> () "foo.bb4Terminator"(%bb4Arg) : (f32) -> ()
^bb5(%bb5Arg : f32): ^bb5(%bb5Arg : f32):
"foo.bb5Terminator"(%bb5Arg) : (f32) -> () "foo.bb5Terminator"(%bb5Arg) : (f32) -> ()
// CHECK: ^[[BB6]]({{.*}}): // CHECK: ^[[BB6]]({{.*}}):
// CHECK-NEXT: "foo.bb6Terminator" // CHECK-NEXT: "foo.bb6Terminator"
^bb6(%bb6Arg : f32): ^bb6(%bb6Arg : f32):
"foo.bb6Terminator"(%bb6Arg) : (f32) -> () "foo.bb6Terminator"(%bb6Arg) : (f32) -> ()
} }
/// Test folding conditional branches that are successors of conditional /// Test folding conditional branches that are successors of conditional
/// branches with the same condition. /// branches with the same condition.
// CHECK-LABEL: func @cond_br_from_cond_br_with_same_condition // CHECK-LABEL: func @cond_br_from_cond_br_with_same_condition
func @cond_br_from_cond_br_with_same_condition(%cond : i1) { func @cond_br_from_cond_br_with_same_condition(%cond : i1) {
// CHECK: cond_br %{{.*}}, ^bb1, ^bb2 // CHECK: cf.cond_br %{{.*}}, ^bb1, ^bb2
// CHECK: ^bb1: // CHECK: ^bb1:
// CHECK: return // CHECK: return
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
cond_br %cond, ^bb3, ^bb2 cf.cond_br %cond, ^bb3, ^bb2
^bb2: ^bb2:
"foo.terminator"() : () -> () "foo.terminator"() : () -> ()
^bb3: ^bb3:
return return
} }
// ----- // -----
// Erase assertion if condition is known to be true at compile time. // Erase assertion if condition is known to be true at compile time.
// CHECK-LABEL: @assert_true // CHECK-LABEL: @assert_true
func @assert_true() { func @assert_true() {
// CHECK-NOT: assert // CHECK-NOT: cf.assert
%true = arith.constant true %true = arith.constant true
assert %true, "Computer says no" cf.assert %true, "Computer says no"
return return
} }
// ----- // -----
// Keep assertion if condition unknown at compile time. // Keep assertion if condition unknown at compile time.
// CHECK-LABEL: @assert // CHECK-LABEL: @cf.assert
// CHECK-SAME: (%[[ARG:.*]]: i1) // CHECK-SAME: (%[[ARG:.*]]: i1)
func @assert(%arg : i1) { func @cf.assert(%arg : i1) {
// CHECK: assert %[[ARG]], "Computer says no" // CHECK: cf.assert %[[ARG]], "Computer says no"
assert %arg, "Computer says no" cf.assert %arg, "Computer says no"
return
}
// -----
// CHECK-LABEL: @branchCondProp
// CHECK: %[[trueval:.+]] = arith.constant true
// CHECK: %[[falseval:.+]] = arith.constant false
// CHECK: "test.consumer1"(%[[trueval]]) : (i1) -> ()
// CHECK: "test.consumer2"(%[[falseval]]) : (i1) -> ()
func @branchCondProp(%arg0: i1) {
cf.cond_br %arg0, ^trueB, ^falseB
^trueB:
"test.consumer1"(%arg0) : (i1) -> ()
cf.br ^exit
^falseB:
"test.consumer2"(%arg0) : (i1) -> ()
cf.br ^exit
^exit:
return return
} }

mlir/test/Dialect/ControlFlow/invalid.mlir

  • This file was moved from mlir/test/Dialect/Standard/parser.mlir.
// RUN: mlir-opt -verify-diagnostics -split-input-file %s // RUN: mlir-opt -verify-diagnostics -split-input-file %s
func @switch_missing_case_value(%flag : i32, %caseOperand : i32) { func @switch_missing_case_value(%flag : i32, %caseOperand : i32) {
switch %flag : i32, [ cf.switch %flag : i32, [
default: ^bb1(%caseOperand : i32), default: ^bb1(%caseOperand : i32),
45: ^bb2(%caseOperand : i32), 45: ^bb2(%caseOperand : i32),
// expected-error@+1 {{expected integer value}} // expected-error@+1 {{expected integer value}}
: ^bb3(%caseOperand : i32) : ^bb3(%caseOperand : i32)
] ]
^bb1(%bb1arg : i32): ^bb1(%bb1arg : i32):
return return
^bb2(%bb2arg : i32): ^bb2(%bb2arg : i32):
return return
^bb3(%bb3arg : i32): ^bb3(%bb3arg : i32):
return return
} }
// ----- // -----
func @switch_wrong_type_case_value(%flag : i32, %caseOperand : i32) { func @switch_wrong_type_case_value(%flag : i32, %caseOperand : i32) {
switch %flag : i32, [ cf.switch %flag : i32, [
default: ^bb1(%caseOperand : i32), default: ^bb1(%caseOperand : i32),
// expected-error@+1 {{expected integer value}} // expected-error@+1 {{expected integer value}}
"hello": ^bb2(%caseOperand : i32) "hello": ^bb2(%caseOperand : i32)
] ]
^bb1(%bb1arg : i32): ^bb1(%bb1arg : i32):
return return
^bb2(%bb2arg : i32): ^bb2(%bb2arg : i32):
return return
^bb3(%bb3arg : i32): ^bb3(%bb3arg : i32):
return return
} }
// ----- // -----
func @switch_missing_comma(%flag : i32, %caseOperand : i32) { func @switch_missing_comma(%flag : i32, %caseOperand : i32) {
switch %flag : i32, [ cf.switch %flag : i32, [
default: ^bb1(%caseOperand : i32), default: ^bb1(%caseOperand : i32),
45: ^bb2(%caseOperand : i32) 45: ^bb2(%caseOperand : i32)
// expected-error@+1 {{expected ']'}} // expected-error@+1 {{expected ']'}}
43: ^bb3(%caseOperand : i32) 43: ^bb3(%caseOperand : i32)
] ]
^bb1(%bb1arg : i32): ^bb1(%bb1arg : i32):
return return
^bb2(%bb2arg : i32): ^bb2(%bb2arg : i32):
return return
^bb3(%bb3arg : i32): ^bb3(%bb3arg : i32):
return return
} }
// ----- // -----
func @switch_missing_default(%flag : i32, %caseOperand : i32) { func @switch_missing_default(%flag : i32, %caseOperand : i32) {
switch %flag : i32, [ cf.switch %flag : i32, [
// expected-error@+1 {{expected 'default'}} // expected-error@+1 {{expected 'default'}}
45: ^bb2(%caseOperand : i32) 45: ^bb2(%caseOperand : i32)
43: ^bb3(%caseOperand : i32) 43: ^bb3(%caseOperand : i32)
] ]
^bb1(%bb1arg : i32): ^bb1(%bb1arg : i32):
return return
^bb2(%bb2arg : i32): ^bb2(%bb2arg : i32):
return return
^bb3(%bb3arg : i32): ^bb3(%bb3arg : i32):
return return
} }

mlir/test/Dialect/ControlFlow/ops.mlir

  • This file was moved from mlir/test/Dialect/Standard/ops.mlir.
// RUN: mlir-opt %s | mlir-opt | FileCheck %s // RUN: mlir-opt %s | mlir-opt | FileCheck %s
// RUN: mlir-opt %s --mlir-print-op-generic | mlir-opt | FileCheck %s // RUN: mlir-opt %s --mlir-print-op-generic | mlir-opt | FileCheck %s
// CHECK-LABEL: @assert // CHECK-LABEL: @assert
func @assert(%arg : i1) { func @assert(%arg : i1) {
assert %arg, "Some message in case this assertion fails." cf.assert %arg, "Some message in case this assertion fails."
return return
} }
// CHECK-LABEL: @atan
func @atan(%arg : f32) -> f32 {
%result = math.atan %arg : f32
return %result : f32
}
// CHECK-LABEL: @atan2
func @atan2(%arg0 : f32, %arg1 : f32) -> f32 {
%result = math.atan2 %arg0, %arg1 : f32
return %result : f32
}
// CHECK-LABEL: func @switch( // CHECK-LABEL: func @switch(
func @switch(%flag : i32, %caseOperand : i32) { func @switch(%flag : i32, %caseOperand : i32) {
switch %flag : i32, [ cf.switch %flag : i32, [
default: ^bb1(%caseOperand : i32), default: ^bb1(%caseOperand : i32),
42: ^bb2(%caseOperand : i32), 42: ^bb2(%caseOperand : i32),
43: ^bb3(%caseOperand : i32) 43: ^bb3(%caseOperand : i32)
] ]
^bb1(%bb1arg : i32): ^bb1(%bb1arg : i32):
return return
^bb2(%bb2arg : i32): ^bb2(%bb2arg : i32):
return return
^bb3(%bb3arg : i32): ^bb3(%bb3arg : i32):
return return
} }
// CHECK-LABEL: func @switch_i64( // CHECK-LABEL: func @switch_i64(
func @switch_i64(%flag : i64, %caseOperand : i32) { func @switch_i64(%flag : i64, %caseOperand : i32) {
switch %flag : i64, [ cf.switch %flag : i64, [
default: ^bb1(%caseOperand : i32), default: ^bb1(%caseOperand : i32),
42: ^bb2(%caseOperand : i32), 42: ^bb2(%caseOperand : i32),
43: ^bb3(%caseOperand : i32) 43: ^bb3(%caseOperand : i32)
] ]
^bb1(%bb1arg : i32): ^bb1(%bb1arg : i32):
return return
^bb2(%bb2arg : i32): ^bb2(%bb2arg : i32):
return return
^bb3(%bb3arg : i32): ^bb3(%bb3arg : i32):
return return
} }

mlir/test/Dialect/GPU/all-reduce-max.mlir

Show All 33 Lines gpu.func @kernel(%arg0 : f32) kernel {
// CHECK: [[VAL_26:%.*]] = arith.muli [[VAL_12]], [[VAL_14]] : i32 // CHECK: [[VAL_26:%.*]] = arith.muli [[VAL_12]], [[VAL_14]] : i32
// CHECK: [[VAL_27:%.*]] = arith.addi [[VAL_25]], [[VAL_18]] : i32 // CHECK: [[VAL_27:%.*]] = arith.addi [[VAL_25]], [[VAL_18]] : i32
// CHECK: [[VAL_28:%.*]] = arith.muli [[VAL_26]], [[VAL_16]] : i32 // CHECK: [[VAL_28:%.*]] = arith.muli [[VAL_26]], [[VAL_16]] : i32
// CHECK: [[VAL_29:%.*]] = arith.andi [[VAL_27]], [[VAL_2]] : i32 // CHECK: [[VAL_29:%.*]] = arith.andi [[VAL_27]], [[VAL_2]] : i32
// CHECK: [[VAL_30:%.*]] = arith.cmpi eq, [[VAL_29]], [[VAL_3]] : i32 // CHECK: [[VAL_30:%.*]] = arith.cmpi eq, [[VAL_29]], [[VAL_3]] : i32
// CHECK: [[VAL_31:%.*]] = arith.subi [[VAL_27]], [[VAL_29]] : i32 // CHECK: [[VAL_31:%.*]] = arith.subi [[VAL_27]], [[VAL_29]] : i32
// CHECK: [[VAL_32:%.*]] = arith.subi [[VAL_28]], [[VAL_31]] : i32 // CHECK: [[VAL_32:%.*]] = arith.subi [[VAL_28]], [[VAL_31]] : i32
// CHECK: [[VAL_33:%.*]] = arith.cmpi slt, [[VAL_32]], [[VAL_5]] : i32 // CHECK: [[VAL_33:%.*]] = arith.cmpi slt, [[VAL_32]], [[VAL_5]] : i32
// CHECK: cond_br [[VAL_33]], ^bb1, ^bb17 // CHECK: cf.cond_br [[VAL_33]], ^bb1, ^bb17
// CHECK: ^bb1: // CHECK: ^bb1:
// CHECK: [[VAL_34:%.*]], [[VAL_35:%.*]] = gpu.shuffle xor [[VAL_0]], [[VAL_6]], [[VAL_32]] : f32 // CHECK: [[VAL_34:%.*]], [[VAL_35:%.*]] = gpu.shuffle xor [[VAL_0]], [[VAL_6]], [[VAL_32]] : f32
// CHECK: cond_br [[VAL_35]], ^bb2, ^bb3 // CHECK: cf.cond_br [[VAL_35]], ^bb2, ^bb3
// CHECK: ^bb2: // CHECK: ^bb2:
// CHECK: [[VAL_36:%.*]] = arith.cmpf ugt, [[VAL_0]], [[VAL_34]] : f32 // CHECK: [[VAL_36:%.*]] = arith.cmpf ugt, [[VAL_0]], [[VAL_34]] : f32
// CHECK: [[VAL_37:%.*]] = arith.select [[VAL_36]], [[VAL_0]], [[VAL_34]] : f32 // CHECK: [[VAL_37:%.*]] = arith.select [[VAL_36]], [[VAL_0]], [[VAL_34]] : f32
// CHECK: br ^bb4([[VAL_37]] : f32) // CHECK: cf.br ^bb4([[VAL_37]] : f32)
// CHECK: ^bb3: // CHECK: ^bb3:
// CHECK: br ^bb4([[VAL_0]] : f32) // CHECK: cf.br ^bb4([[VAL_0]] : f32)
// CHECK: ^bb4([[VAL_38:%.*]]: f32): // CHECK: ^bb4([[VAL_38:%.*]]: f32):
// CHECK: [[VAL_39:%.*]], [[VAL_40:%.*]] = gpu.shuffle xor [[VAL_38]], [[VAL_7]], [[VAL_32]] : f32 // CHECK: [[VAL_39:%.*]], [[VAL_40:%.*]] = gpu.shuffle xor [[VAL_38]], [[VAL_7]], [[VAL_32]] : f32
// CHECK: cond_br [[VAL_40]], ^bb5, ^bb6 // CHECK: cf.cond_br [[VAL_40]], ^bb5, ^bb6
// CHECK: ^bb5: // CHECK: ^bb5:
// CHECK: [[VAL_41:%.*]] = arith.cmpf ugt, [[VAL_38]], [[VAL_39]] : f32 // CHECK: [[VAL_41:%.*]] = arith.cmpf ugt, [[VAL_38]], [[VAL_39]] : f32
// CHECK: [[VAL_42:%.*]] = arith.select [[VAL_41]], [[VAL_38]], [[VAL_39]] : f32 // CHECK: [[VAL_42:%.*]] = arith.select [[VAL_41]], [[VAL_38]], [[VAL_39]] : f32
// CHECK: br ^bb7([[VAL_42]] : f32) // CHECK: cf.br ^bb7([[VAL_42]] : f32)
// CHECK: ^bb6: // CHECK: ^bb6:
// CHECK: br ^bb7([[VAL_38]] : f32) // CHECK: cf.br ^bb7([[VAL_38]] : f32)
// CHECK: ^bb7([[VAL_43:%.*]]: f32): // CHECK: ^bb7([[VAL_43:%.*]]: f32):
// CHECK: [[VAL_44:%.*]], [[VAL_45:%.*]] = gpu.shuffle xor [[VAL_43]], [[VAL_8]], [[VAL_32]] : f32 // CHECK: [[VAL_44:%.*]], [[VAL_45:%.*]] = gpu.shuffle xor [[VAL_43]], [[VAL_8]], [[VAL_32]] : f32
// CHECK: cond_br [[VAL_45]], ^bb8, ^bb9 // CHECK: cf.cond_br [[VAL_45]], ^bb8, ^bb9
// CHECK: ^bb8: // CHECK: ^bb8:
// CHECK: [[VAL_46:%.*]] = arith.cmpf ugt, [[VAL_43]], [[VAL_44]] : f32 // CHECK: [[VAL_46:%.*]] = arith.cmpf ugt, [[VAL_43]], [[VAL_44]] : f32
// CHECK: [[VAL_47:%.*]] = arith.select [[VAL_46]], [[VAL_43]], [[VAL_44]] : f32 // CHECK: [[VAL_47:%.*]] = arith.select [[VAL_46]], [[VAL_43]], [[VAL_44]] : f32
// CHECK: br ^bb10([[VAL_47]] : f32) // CHECK: cf.br ^bb10([[VAL_47]] : f32)
// CHECK: ^bb9: // CHECK: ^bb9:
// CHECK: br ^bb10([[VAL_43]] : f32) // CHECK: cf.br ^bb10([[VAL_43]] : f32)
// CHECK: ^bb10([[VAL_48:%.*]]: f32): // CHECK: ^bb10([[VAL_48:%.*]]: f32):
// CHECK: [[VAL_49:%.*]], [[VAL_50:%.*]] = gpu.shuffle xor [[VAL_48]], [[VAL_9]], [[VAL_32]] : f32 // CHECK: [[VAL_49:%.*]], [[VAL_50:%.*]] = gpu.shuffle xor [[VAL_48]], [[VAL_9]], [[VAL_32]] : f32
// CHECK: cond_br [[VAL_50]], ^bb11, ^bb12 // CHECK: cf.cond_br [[VAL_50]], ^bb11, ^bb12
// CHECK: ^bb11: // CHECK: ^bb11:
// CHECK: [[VAL_51:%.*]] = arith.cmpf ugt, [[VAL_48]], [[VAL_49]] : f32 // CHECK: [[VAL_51:%.*]] = arith.cmpf ugt, [[VAL_48]], [[VAL_49]] : f32
// CHECK: [[VAL_52:%.*]] = arith.select [[VAL_51]], [[VAL_48]], [[VAL_49]] : f32 // CHECK: [[VAL_52:%.*]] = arith.select [[VAL_51]], [[VAL_48]], [[VAL_49]] : f32
// CHECK: br ^bb13([[VAL_52]] : f32) // CHECK: cf.br ^bb13([[VAL_52]] : f32)
// CHECK: ^bb12: // CHECK: ^bb12:
// CHECK: br ^bb13([[VAL_48]] : f32) // CHECK: cf.br ^bb13([[VAL_48]] : f32)
// CHECK: ^bb13([[VAL_53:%.*]]: f32): // CHECK: ^bb13([[VAL_53:%.*]]: f32):
// CHECK: [[VAL_54:%.*]], [[VAL_55:%.*]] = gpu.shuffle xor [[VAL_53]], [[VAL_10]], [[VAL_32]] : f32 // CHECK: [[VAL_54:%.*]], [[VAL_55:%.*]] = gpu.shuffle xor [[VAL_53]], [[VAL_10]], [[VAL_32]] : f32
// CHECK: cond_br [[VAL_55]], ^bb14, ^bb15 // CHECK: cf.cond_br [[VAL_55]], ^bb14, ^bb15
// CHECK: ^bb14: // CHECK: ^bb14:
// CHECK: [[VAL_56:%.*]] = arith.cmpf ugt, [[VAL_53]], [[VAL_54]] : f32 // CHECK: [[VAL_56:%.*]] = arith.cmpf ugt, [[VAL_53]], [[VAL_54]] : f32
// CHECK: [[VAL_57:%.*]] = arith.select [[VAL_56]], [[VAL_53]], [[VAL_54]] : f32 // CHECK: [[VAL_57:%.*]] = arith.select [[VAL_56]], [[VAL_53]], [[VAL_54]] : f32
// CHECK: br ^bb16([[VAL_57]] : f32) // CHECK: cf.br ^bb16([[VAL_57]] : f32)
// CHECK: ^bb15: // CHECK: ^bb15:
// CHECK: br ^bb16([[VAL_53]] : f32) // CHECK: cf.br ^bb16([[VAL_53]] : f32)
// CHECK: ^bb16([[VAL_58:%.*]]: f32): // CHECK: ^bb16([[VAL_58:%.*]]: f32):
// CHECK: br ^bb18([[VAL_58]] : f32) // CHECK: cf.br ^bb18([[VAL_58]] : f32)
// CHECK: ^bb17: // CHECK: ^bb17:
// CHECK: [[VAL_59:%.*]], [[VAL_60:%.*]] = gpu.shuffle xor [[VAL_0]], [[VAL_6]], [[VAL_5]] : f32 // CHECK: [[VAL_59:%.*]], [[VAL_60:%.*]] = gpu.shuffle xor [[VAL_0]], [[VAL_6]], [[VAL_5]] : f32
// CHECK: [[VAL_61:%.*]] = arith.cmpf ugt, [[VAL_0]], [[VAL_59]] : f32 // CHECK: [[VAL_61:%.*]] = arith.cmpf ugt, [[VAL_0]], [[VAL_59]] : f32
// CHECK: [[VAL_62:%.*]] = arith.select [[VAL_61]], [[VAL_0]], [[VAL_59]] : f32 // CHECK: [[VAL_62:%.*]] = arith.select [[VAL_61]], [[VAL_0]], [[VAL_59]] : f32
// CHECK: [[VAL_63:%.*]], [[VAL_64:%.*]] = gpu.shuffle xor [[VAL_62]], [[VAL_7]], [[VAL_5]] : f32 // CHECK: [[VAL_63:%.*]], [[VAL_64:%.*]] = gpu.shuffle xor [[VAL_62]], [[VAL_7]], [[VAL_5]] : f32
// CHECK: [[VAL_65:%.*]] = arith.cmpf ugt, [[VAL_62]], [[VAL_63]] : f32 // CHECK: [[VAL_65:%.*]] = arith.cmpf ugt, [[VAL_62]], [[VAL_63]] : f32
// CHECK: [[VAL_66:%.*]] = arith.select [[VAL_65]], [[VAL_62]], [[VAL_63]] : f32 // CHECK: [[VAL_66:%.*]] = arith.select [[VAL_65]], [[VAL_62]], [[VAL_63]] : f32
// CHECK: [[VAL_67:%.*]], [[VAL_68:%.*]] = gpu.shuffle xor [[VAL_66]], [[VAL_8]], [[VAL_5]] : f32 // CHECK: [[VAL_67:%.*]], [[VAL_68:%.*]] = gpu.shuffle xor [[VAL_66]], [[VAL_8]], [[VAL_5]] : f32
// CHECK: [[VAL_69:%.*]] = arith.cmpf ugt, [[VAL_66]], [[VAL_67]] : f32 // CHECK: [[VAL_69:%.*]] = arith.cmpf ugt, [[VAL_66]], [[VAL_67]] : f32
// CHECK: [[VAL_70:%.*]] = arith.select [[VAL_69]], [[VAL_66]], [[VAL_67]] : f32 // CHECK: [[VAL_70:%.*]] = arith.select [[VAL_69]], [[VAL_66]], [[VAL_67]] : f32
// CHECK: [[VAL_71:%.*]], [[VAL_72:%.*]] = gpu.shuffle xor [[VAL_70]], [[VAL_9]], [[VAL_5]] : f32 // CHECK: [[VAL_71:%.*]], [[VAL_72:%.*]] = gpu.shuffle xor [[VAL_70]], [[VAL_9]], [[VAL_5]] : f32
// CHECK: [[VAL_73:%.*]] = arith.cmpf ugt, [[VAL_70]], [[VAL_71]] : f32 // CHECK: [[VAL_73:%.*]] = arith.cmpf ugt, [[VAL_70]], [[VAL_71]] : f32
// CHECK: [[VAL_74:%.*]] = arith.select [[VAL_73]], [[VAL_70]], [[VAL_71]] : f32 // CHECK: [[VAL_74:%.*]] = arith.select [[VAL_73]], [[VAL_70]], [[VAL_71]] : f32
// CHECK: [[VAL_75:%.*]], [[VAL_76:%.*]] = gpu.shuffle xor [[VAL_74]], [[VAL_10]], [[VAL_5]] : f32 // CHECK: [[VAL_75:%.*]], [[VAL_76:%.*]] = gpu.shuffle xor [[VAL_74]], [[VAL_10]], [[VAL_5]] : f32
// CHECK: [[VAL_77:%.*]] = arith.cmpf ugt, [[VAL_74]], [[VAL_75]] : f32 // CHECK: [[VAL_77:%.*]] = arith.cmpf ugt, [[VAL_74]], [[VAL_75]] : f32
// CHECK: [[VAL_78:%.*]] = arith.select [[VAL_77]], [[VAL_74]], [[VAL_75]] : f32 // CHECK: [[VAL_78:%.*]] = arith.select [[VAL_77]], [[VAL_74]], [[VAL_75]] : f32
// CHECK: br ^bb18([[VAL_78]] : f32) // CHECK: cf.br ^bb18([[VAL_78]] : f32)
// CHECK: ^bb18([[VAL_79:%.*]]: f32): // CHECK: ^bb18([[VAL_79:%.*]]: f32):
// CHECK: cond_br [[VAL_30]], ^bb19, ^bb20 // CHECK: cf.cond_br [[VAL_30]], ^bb19, ^bb20
// CHECK: ^bb19: // CHECK: ^bb19:
// CHECK: [[VAL_80:%.*]] = arith.divsi [[VAL_27]], [[VAL_5]] : i32 // CHECK: [[VAL_80:%.*]] = arith.divsi [[VAL_27]], [[VAL_5]] : i32
// CHECK: [[VAL_81:%.*]] = arith.index_cast [[VAL_80]] : i32 to index // CHECK: [[VAL_81:%.*]] = arith.index_cast [[VAL_80]] : i32 to index
// CHECK: store [[VAL_79]], [[VAL_1]]{{\[}}[[VAL_81]]] : memref<32xf32, 3> // CHECK: store [[VAL_79]], [[VAL_1]]{{\[}}[[VAL_81]]] : memref<32xf32, 3>
// CHECK: br ^bb21 // CHECK: cf.br ^bb21
// CHECK: ^bb20: // CHECK: ^bb20:
// CHECK: br ^bb21 // CHECK: cf.br ^bb21
// CHECK: ^bb21: // CHECK: ^bb21:
// CHECK: gpu.barrier // CHECK: gpu.barrier
// CHECK: [[VAL_82:%.*]] = arith.addi [[VAL_28]], [[VAL_2]] : i32 // CHECK: [[VAL_82:%.*]] = arith.addi [[VAL_28]], [[VAL_2]] : i32
// CHECK: [[VAL_83:%.*]] = arith.divsi [[VAL_82]], [[VAL_5]] : i32 // CHECK: [[VAL_83:%.*]] = arith.divsi [[VAL_82]], [[VAL_5]] : i32
// CHECK: [[VAL_84:%.*]] = arith.cmpi slt, [[VAL_27]], [[VAL_83]] : i32 // CHECK: [[VAL_84:%.*]] = arith.cmpi slt, [[VAL_27]], [[VAL_83]] : i32
// CHECK: cond_br [[VAL_84]], ^bb22, ^bb41 // CHECK: cf.cond_br [[VAL_84]], ^bb22, ^bb41
// CHECK: ^bb22: // CHECK: ^bb22:
// CHECK: [[VAL_85:%.*]] = arith.index_cast [[VAL_27]] : i32 to index // CHECK: [[VAL_85:%.*]] = arith.index_cast [[VAL_27]] : i32 to index
// CHECK: [[VAL_86:%.*]] = memref.load [[VAL_1]]{{\[}}[[VAL_85]]] : memref<32xf32, 3> // CHECK: [[VAL_86:%.*]] = memref.load [[VAL_1]]{{\[}}[[VAL_85]]] : memref<32xf32, 3>
// CHECK: [[VAL_87:%.*]] = arith.cmpi slt, [[VAL_83]], [[VAL_5]] : i32 // CHECK: [[VAL_87:%.*]] = arith.cmpi slt, [[VAL_83]], [[VAL_5]] : i32
// CHECK: cond_br [[VAL_87]], ^bb23, ^bb39 // CHECK: cf.cond_br [[VAL_87]], ^bb23, ^bb39
// CHECK: ^bb23: // CHECK: ^bb23:
// CHECK: [[VAL_88:%.*]], [[VAL_89:%.*]] = gpu.shuffle xor [[VAL_86]], [[VAL_6]], [[VAL_83]] : f32 // CHECK: [[VAL_88:%.*]], [[VAL_89:%.*]] = gpu.shuffle xor [[VAL_86]], [[VAL_6]], [[VAL_83]] : f32
// CHECK: cond_br [[VAL_89]], ^bb24, ^bb25 // CHECK: cf.cond_br [[VAL_89]], ^bb24, ^bb25
// CHECK: ^bb24: // CHECK: ^bb24:
// CHECK: [[VAL_90:%.*]] = arith.cmpf ugt, [[VAL_86]], [[VAL_88]] : f32 // CHECK: [[VAL_90:%.*]] = arith.cmpf ugt, [[VAL_86]], [[VAL_88]] : f32
// CHECK: [[VAL_91:%.*]] = arith.select [[VAL_90]], [[VAL_86]], [[VAL_88]] : f32 // CHECK: [[VAL_91:%.*]] = arith.select [[VAL_90]], [[VAL_86]], [[VAL_88]] : f32
// CHECK: br ^bb26([[VAL_91]] : f32) // CHECK: cf.br ^bb26([[VAL_91]] : f32)
// CHECK: ^bb25: // CHECK: ^bb25:
// CHECK: br ^bb26([[VAL_86]] : f32) // CHECK: cf.br ^bb26([[VAL_86]] : f32)
// CHECK: ^bb26([[VAL_92:%.*]]: f32): // CHECK: ^bb26([[VAL_92:%.*]]: f32):
// CHECK: [[VAL_93:%.*]], [[VAL_94:%.*]] = gpu.shuffle xor [[VAL_92]], [[VAL_7]], [[VAL_83]] : f32 // CHECK: [[VAL_93:%.*]], [[VAL_94:%.*]] = gpu.shuffle xor [[VAL_92]], [[VAL_7]], [[VAL_83]] : f32
// CHECK: cond_br [[VAL_94]], ^bb27, ^bb28 // CHECK: cf.cond_br [[VAL_94]], ^bb27, ^bb28
// CHECK: ^bb27: // CHECK: ^bb27:
// CHECK: [[VAL_95:%.*]] = arith.cmpf ugt, [[VAL_92]], [[VAL_93]] : f32 // CHECK: [[VAL_95:%.*]] = arith.cmpf ugt, [[VAL_92]], [[VAL_93]] : f32
// CHECK: [[VAL_96:%.*]] = arith.select [[VAL_95]], [[VAL_92]], [[VAL_93]] : f32 // CHECK: [[VAL_96:%.*]] = arith.select [[VAL_95]], [[VAL_92]], [[VAL_93]] : f32
// CHECK: br ^bb29([[VAL_96]] : f32) // CHECK: cf.br ^bb29([[VAL_96]] : f32)
// CHECK: ^bb28: // CHECK: ^bb28:
// CHECK: br ^bb29([[VAL_92]] : f32) // CHECK: cf.br ^bb29([[VAL_92]] : f32)
// CHECK: ^bb29([[VAL_97:%.*]]: f32): // CHECK: ^bb29([[VAL_97:%.*]]: f32):
// CHECK: [[VAL_98:%.*]], [[VAL_99:%.*]] = gpu.shuffle xor [[VAL_97]], [[VAL_8]], [[VAL_83]] : f32 // CHECK: [[VAL_98:%.*]], [[VAL_99:%.*]] = gpu.shuffle xor [[VAL_97]], [[VAL_8]], [[VAL_83]] : f32
// CHECK: cond_br [[VAL_99]], ^bb30, ^bb31 // CHECK: cf.cond_br [[VAL_99]], ^bb30, ^bb31
// CHECK: ^bb30: // CHECK: ^bb30:
// CHECK: [[VAL_100:%.*]] = arith.cmpf ugt, [[VAL_97]], [[VAL_98]] : f32 // CHECK: [[VAL_100:%.*]] = arith.cmpf ugt, [[VAL_97]], [[VAL_98]] : f32
// CHECK: [[VAL_101:%.*]] = arith.select [[VAL_100]], [[VAL_97]], [[VAL_98]] : f32 // CHECK: [[VAL_101:%.*]] = arith.select [[VAL_100]], [[VAL_97]], [[VAL_98]] : f32
// CHECK: br ^bb32([[VAL_101]] : f32) // CHECK: cf.br ^bb32([[VAL_101]] : f32)
// CHECK: ^bb31: // CHECK: ^bb31:
// CHECK: br ^bb32([[VAL_97]] : f32) // CHECK: cf.br ^bb32([[VAL_97]] : f32)
// CHECK: ^bb32([[VAL_102:%.*]]: f32): // CHECK: ^bb32([[VAL_102:%.*]]: f32):
// CHECK: [[VAL_103:%.*]], [[VAL_104:%.*]] = gpu.shuffle xor [[VAL_102]], [[VAL_9]], [[VAL_83]] : f32 // CHECK: [[VAL_103:%.*]], [[VAL_104:%.*]] = gpu.shuffle xor [[VAL_102]], [[VAL_9]], [[VAL_83]] : f32
// CHECK: cond_br [[VAL_104]], ^bb33, ^bb34 // CHECK: cf.cond_br [[VAL_104]], ^bb33, ^bb34
// CHECK: ^bb33: // CHECK: ^bb33:
// CHECK: [[VAL_105:%.*]] = arith.cmpf ugt, [[VAL_102]], [[VAL_103]] : f32 // CHECK: [[VAL_105:%.*]] = arith.cmpf ugt, [[VAL_102]], [[VAL_103]] : f32
// CHECK: [[VAL_106:%.*]] = arith.select [[VAL_105]], [[VAL_102]], [[VAL_103]] : f32 // CHECK: [[VAL_106:%.*]] = arith.select [[VAL_105]], [[VAL_102]], [[VAL_103]] : f32
// CHECK: br ^bb35([[VAL_106]] : f32) // CHECK: cf.br ^bb35([[VAL_106]] : f32)
// CHECK: ^bb34: // CHECK: ^bb34:
// CHECK: br ^bb35([[VAL_102]] : f32) // CHECK: cf.br ^bb35([[VAL_102]] : f32)
// CHECK: ^bb35([[VAL_107:%.*]]: f32): // CHECK: ^bb35([[VAL_107:%.*]]: f32):
// CHECK: [[VAL_108:%.*]], [[VAL_109:%.*]] = gpu.shuffle xor [[VAL_107]], [[VAL_10]], [[VAL_83]] : f32 // CHECK: [[VAL_108:%.*]], [[VAL_109:%.*]] = gpu.shuffle xor [[VAL_107]], [[VAL_10]], [[VAL_83]] : f32
// CHECK: cond_br [[VAL_109]], ^bb36, ^bb37 // CHECK: cf.cond_br [[VAL_109]], ^bb36, ^bb37
// CHECK: ^bb36: // CHECK: ^bb36:
// CHECK: [[VAL_110:%.*]] = arith.cmpf ugt, [[VAL_107]], [[VAL_108]] : f32 // CHECK: [[VAL_110:%.*]] = arith.cmpf ugt, [[VAL_107]], [[VAL_108]] : f32
// CHECK: [[VAL_111:%.*]] = arith.select [[VAL_110]], [[VAL_107]], [[VAL_108]] : f32 // CHECK: [[VAL_111:%.*]] = arith.select [[VAL_110]], [[VAL_107]], [[VAL_108]] : f32
// CHECK: br ^bb38([[VAL_111]] : f32) // CHECK: cf.br ^bb38([[VAL_111]] : f32)
// CHECK: ^bb37: // CHECK: ^bb37:
// CHECK: br ^bb38([[VAL_107]] : f32) // CHECK: cf.br ^bb38([[VAL_107]] : f32)
// CHECK: ^bb38([[VAL_112:%.*]]: f32): // CHECK: ^bb38([[VAL_112:%.*]]: f32):
// CHECK: br ^bb40([[VAL_112]] : f32) // CHECK: cf.br ^bb40([[VAL_112]] : f32)
// CHECK: ^bb39: // CHECK: ^bb39:
// CHECK: [[VAL_113:%.*]], [[VAL_114:%.*]] = gpu.shuffle xor [[VAL_86]], [[VAL_6]], [[VAL_5]] : f32 // CHECK: [[VAL_113:%.*]], [[VAL_114:%.*]] = gpu.shuffle xor [[VAL_86]], [[VAL_6]], [[VAL_5]] : f32
// CHECK: [[VAL_115:%.*]] = arith.cmpf ugt, [[VAL_86]], [[VAL_113]] : f32 // CHECK: [[VAL_115:%.*]] = arith.cmpf ugt, [[VAL_86]], [[VAL_113]] : f32
// CHECK: [[VAL_116:%.*]] = arith.select [[VAL_115]], [[VAL_86]], [[VAL_113]] : f32 // CHECK: [[VAL_116:%.*]] = arith.select [[VAL_115]], [[VAL_86]], [[VAL_113]] : f32
// CHECK: [[VAL_117:%.*]], [[VAL_118:%.*]] = gpu.shuffle xor [[VAL_116]], [[VAL_7]], [[VAL_5]] : f32 // CHECK: [[VAL_117:%.*]], [[VAL_118:%.*]] = gpu.shuffle xor [[VAL_116]], [[VAL_7]], [[VAL_5]] : f32
// CHECK: [[VAL_119:%.*]] = arith.cmpf ugt, [[VAL_116]], [[VAL_117]] : f32 // CHECK: [[VAL_119:%.*]] = arith.cmpf ugt, [[VAL_116]], [[VAL_117]] : f32
// CHECK: [[VAL_120:%.*]] = arith.select [[VAL_119]], [[VAL_116]], [[VAL_117]] : f32 // CHECK: [[VAL_120:%.*]] = arith.select [[VAL_119]], [[VAL_116]], [[VAL_117]] : f32
// CHECK: [[VAL_121:%.*]], [[VAL_122:%.*]] = gpu.shuffle xor [[VAL_120]], [[VAL_8]], [[VAL_5]] : f32 // CHECK: [[VAL_121:%.*]], [[VAL_122:%.*]] = gpu.shuffle xor [[VAL_120]], [[VAL_8]], [[VAL_5]] : f32
// CHECK: [[VAL_123:%.*]] = arith.cmpf ugt, [[VAL_120]], [[VAL_121]] : f32 // CHECK: [[VAL_123:%.*]] = arith.cmpf ugt, [[VAL_120]], [[VAL_121]] : f32
// CHECK: [[VAL_124:%.*]] = arith.select [[VAL_123]], [[VAL_120]], [[VAL_121]] : f32 // CHECK: [[VAL_124:%.*]] = arith.select [[VAL_123]], [[VAL_120]], [[VAL_121]] : f32
// CHECK: [[VAL_125:%.*]], [[VAL_126:%.*]] = gpu.shuffle xor [[VAL_124]], [[VAL_9]], [[VAL_5]] : f32 // CHECK: [[VAL_125:%.*]], [[VAL_126:%.*]] = gpu.shuffle xor [[VAL_124]], [[VAL_9]], [[VAL_5]] : f32
// CHECK: [[VAL_127:%.*]] = arith.cmpf ugt, [[VAL_124]], [[VAL_125]] : f32 // CHECK: [[VAL_127:%.*]] = arith.cmpf ugt, [[VAL_124]], [[VAL_125]] : f32
// CHECK: [[VAL_128:%.*]] = arith.select [[VAL_127]], [[VAL_124]], [[VAL_125]] : f32 // CHECK: [[VAL_128:%.*]] = arith.select [[VAL_127]], [[VAL_124]], [[VAL_125]] : f32
// CHECK: [[VAL_129:%.*]], [[VAL_130:%.*]] = gpu.shuffle xor [[VAL_128]], [[VAL_10]], [[VAL_5]] : f32 // CHECK: [[VAL_129:%.*]], [[VAL_130:%.*]] = gpu.shuffle xor [[VAL_128]], [[VAL_10]], [[VAL_5]] : f32
// CHECK: [[VAL_131:%.*]] = arith.cmpf ugt, [[VAL_128]], [[VAL_129]] : f32 // CHECK: [[VAL_131:%.*]] = arith.cmpf ugt, [[VAL_128]], [[VAL_129]] : f32
// CHECK: [[VAL_132:%.*]] = arith.select [[VAL_131]], [[VAL_128]], [[VAL_129]] : f32 // CHECK: [[VAL_132:%.*]] = arith.select [[VAL_131]], [[VAL_128]], [[VAL_129]] : f32
// CHECK: br ^bb40([[VAL_132]] : f32) // CHECK: cf.br ^bb40([[VAL_132]] : f32)
// CHECK: ^bb40([[VAL_133:%.*]]: f32): // CHECK: ^bb40([[VAL_133:%.*]]: f32):
// CHECK: store [[VAL_133]], [[VAL_1]]{{\[}}[[VAL_4]]] : memref<32xf32, 3> // CHECK: store [[VAL_133]], [[VAL_1]]{{\[}}[[VAL_4]]] : memref<32xf32, 3>
// CHECK: br ^bb42 // CHECK: cf.br ^bb42
// CHECK: ^bb41: // CHECK: ^bb41:
// CHECK: br ^bb42 // CHECK: cf.br ^bb42
// CHECK: ^bb42: // CHECK: ^bb42:
// CHECK: gpu.barrier // CHECK: gpu.barrier
%sum = gpu.all_reduce max %arg0 {} : (f32) -> (f32) %sum = gpu.all_reduce max %arg0 {} : (f32) -> (f32)
gpu.return gpu.return
} }
} }

mlir/test/Dialect/GPU/all-reduce.mlir

Show All 33 Lines gpu.func @kernel(%arg0 : f32) kernel {
// CHECK: [[VAL_26:%.*]] = arith.muli [[VAL_12]], [[VAL_14]] : i32 // CHECK: [[VAL_26:%.*]] = arith.muli [[VAL_12]], [[VAL_14]] : i32
// CHECK: [[VAL_27:%.*]] = arith.addi [[VAL_25]], [[VAL_18]] : i32 // CHECK: [[VAL_27:%.*]] = arith.addi [[VAL_25]], [[VAL_18]] : i32
// CHECK: [[VAL_28:%.*]] = arith.muli [[VAL_26]], [[VAL_16]] : i32 // CHECK: [[VAL_28:%.*]] = arith.muli [[VAL_26]], [[VAL_16]] : i32
// CHECK: [[VAL_29:%.*]] = arith.andi [[VAL_27]], [[VAL_2]] : i32 // CHECK: [[VAL_29:%.*]] = arith.andi [[VAL_27]], [[VAL_2]] : i32
// CHECK: [[VAL_30:%.*]] = arith.cmpi eq, [[VAL_29]], [[VAL_3]] : i32 // CHECK: [[VAL_30:%.*]] = arith.cmpi eq, [[VAL_29]], [[VAL_3]] : i32
// CHECK: [[VAL_31:%.*]] = arith.subi [[VAL_27]], [[VAL_29]] : i32 // CHECK: [[VAL_31:%.*]] = arith.subi [[VAL_27]], [[VAL_29]] : i32
// CHECK: [[VAL_32:%.*]] = arith.subi [[VAL_28]], [[VAL_31]] : i32 // CHECK: [[VAL_32:%.*]] = arith.subi [[VAL_28]], [[VAL_31]] : i32
// CHECK: [[VAL_33:%.*]] = arith.cmpi slt, [[VAL_32]], [[VAL_5]] : i32 // CHECK: [[VAL_33:%.*]] = arith.cmpi slt, [[VAL_32]], [[VAL_5]] : i32
// CHECK: cond_br [[VAL_33]], ^bb1, ^bb17 // CHECK: cf.cond_br [[VAL_33]], ^bb1, ^bb17
// CHECK: ^bb1: // CHECK: ^bb1:
// CHECK: [[VAL_34:%.*]], [[VAL_35:%.*]] = gpu.shuffle xor [[VAL_0]], [[VAL_6]], [[VAL_32]] : f32 // CHECK: [[VAL_34:%.*]], [[VAL_35:%.*]] = gpu.shuffle xor [[VAL_0]], [[VAL_6]], [[VAL_32]] : f32
// CHECK: cond_br [[VAL_35]], ^bb2, ^bb3 // CHECK: cf.cond_br [[VAL_35]], ^bb2, ^bb3
// CHECK: ^bb2: // CHECK: ^bb2:
// CHECK: [[VAL_36:%.*]] = arith.addf [[VAL_0]], [[VAL_34]] : f32 // CHECK: [[VAL_36:%.*]] = arith.addf [[VAL_0]], [[VAL_34]] : f32
// CHECK: br ^bb4([[VAL_36]] : f32) // CHECK: cf.br ^bb4([[VAL_36]] : f32)
// CHECK: ^bb3: // CHECK: ^bb3:
// CHECK: br ^bb4([[VAL_0]] : f32) // CHECK: cf.br ^bb4([[VAL_0]] : f32)
// CHECK: ^bb4([[VAL_37:%.*]]: f32): // CHECK: ^bb4([[VAL_37:%.*]]: f32):
// CHECK: [[VAL_38:%.*]], [[VAL_39:%.*]] = gpu.shuffle xor [[VAL_37]], [[VAL_7]], [[VAL_32]] : f32 // CHECK: [[VAL_38:%.*]], [[VAL_39:%.*]] = gpu.shuffle xor [[VAL_37]], [[VAL_7]], [[VAL_32]] : f32
// CHECK: cond_br [[VAL_39]], ^bb5, ^bb6 // CHECK: cf.cond_br [[VAL_39]], ^bb5, ^bb6
// CHECK: ^bb5: // CHECK: ^bb5:
// CHECK: [[VAL_40:%.*]] = arith.addf [[VAL_37]], [[VAL_38]] : f32 // CHECK: [[VAL_40:%.*]] = arith.addf [[VAL_37]], [[VAL_38]] : f32
// CHECK: br ^bb7([[VAL_40]] : f32) // CHECK: cf.br ^bb7([[VAL_40]] : f32)
// CHECK: ^bb6: // CHECK: ^bb6:
// CHECK: br ^bb7([[VAL_37]] : f32) // CHECK: cf.br ^bb7([[VAL_37]] : f32)
// CHECK: ^bb7([[VAL_41:%.*]]: f32): // CHECK: ^bb7([[VAL_41:%.*]]: f32):
// CHECK: [[VAL_42:%.*]], [[VAL_43:%.*]] = gpu.shuffle xor [[VAL_41]], [[VAL_8]], [[VAL_32]] : f32 // CHECK: [[VAL_42:%.*]], [[VAL_43:%.*]] = gpu.shuffle xor [[VAL_41]], [[VAL_8]], [[VAL_32]] : f32
// CHECK: cond_br [[VAL_43]], ^bb8, ^bb9 // CHECK: cf.cond_br [[VAL_43]], ^bb8, ^bb9
// CHECK: ^bb8: // CHECK: ^bb8:
// CHECK: [[VAL_44:%.*]] = arith.addf [[VAL_41]], [[VAL_42]] : f32 // CHECK: [[VAL_44:%.*]] = arith.addf [[VAL_41]], [[VAL_42]] : f32
// CHECK: br ^bb10([[VAL_44]] : f32) // CHECK: cf.br ^bb10([[VAL_44]] : f32)
// CHECK: ^bb9: // CHECK: ^bb9:
// CHECK: br ^bb10([[VAL_41]] : f32) // CHECK: cf.br ^bb10([[VAL_41]] : f32)
// CHECK: ^bb10([[VAL_45:%.*]]: f32): // CHECK: ^bb10([[VAL_45:%.*]]: f32):
// CHECK: [[VAL_46:%.*]], [[VAL_47:%.*]] = gpu.shuffle xor [[VAL_45]], [[VAL_9]], [[VAL_32]] : f32 // CHECK: [[VAL_46:%.*]], [[VAL_47:%.*]] = gpu.shuffle xor [[VAL_45]], [[VAL_9]], [[VAL_32]] : f32
// CHECK: cond_br [[VAL_47]], ^bb11, ^bb12 // CHECK: cf.cond_br [[VAL_47]], ^bb11, ^bb12
// CHECK: ^bb11: // CHECK: ^bb11:
// CHECK: [[VAL_48:%.*]] = arith.addf [[VAL_45]], [[VAL_46]] : f32 // CHECK: [[VAL_48:%.*]] = arith.addf [[VAL_45]], [[VAL_46]] : f32
// CHECK: br ^bb13([[VAL_48]] : f32) // CHECK: cf.br ^bb13([[VAL_48]] : f32)
// CHECK: ^bb12: // CHECK: ^bb12:
// CHECK: br ^bb13([[VAL_45]] : f32) // CHECK: cf.br ^bb13([[VAL_45]] : f32)
// CHECK: ^bb13([[VAL_49:%.*]]: f32): // CHECK: ^bb13([[VAL_49:%.*]]: f32):
// CHECK: [[VAL_50:%.*]], [[VAL_51:%.*]] = gpu.shuffle xor [[VAL_49]], [[VAL_10]], [[VAL_32]] : f32 // CHECK: [[VAL_50:%.*]], [[VAL_51:%.*]] = gpu.shuffle xor [[VAL_49]], [[VAL_10]], [[VAL_32]] : f32
// CHECK: cond_br [[VAL_51]], ^bb14, ^bb15 // CHECK: cf.cond_br [[VAL_51]], ^bb14, ^bb15
// CHECK: ^bb14: // CHECK: ^bb14:
// CHECK: [[VAL_52:%.*]] = arith.addf [[VAL_49]], [[VAL_50]] : f32 // CHECK: [[VAL_52:%.*]] = arith.addf [[VAL_49]], [[VAL_50]] : f32
// CHECK: br ^bb16([[VAL_52]] : f32) // CHECK: cf.br ^bb16([[VAL_52]] : f32)
// CHECK: ^bb15: // CHECK: ^bb15:
// CHECK: br ^bb16([[VAL_49]] : f32) // CHECK: cf.br ^bb16([[VAL_49]] : f32)
// CHECK: ^bb16([[VAL_53:%.*]]: f32): // CHECK: ^bb16([[VAL_53:%.*]]: f32):
// CHECK: br ^bb18([[VAL_53]] : f32) // CHECK: cf.br ^bb18([[VAL_53]] : f32)
// CHECK: ^bb17: // CHECK: ^bb17:
// CHECK: [[VAL_54:%.*]], [[VAL_55:%.*]] = gpu.shuffle xor [[VAL_0]], [[VAL_6]], [[VAL_5]] : f32 // CHECK: [[VAL_54:%.*]], [[VAL_55:%.*]] = gpu.shuffle xor [[VAL_0]], [[VAL_6]], [[VAL_5]] : f32
// CHECK: [[VAL_56:%.*]] = arith.addf [[VAL_0]], [[VAL_54]] : f32 // CHECK: [[VAL_56:%.*]] = arith.addf [[VAL_0]], [[VAL_54]] : f32
// CHECK: [[VAL_57:%.*]], [[VAL_58:%.*]] = gpu.shuffle xor [[VAL_56]], [[VAL_7]], [[VAL_5]] : f32 // CHECK: [[VAL_57:%.*]], [[VAL_58:%.*]] = gpu.shuffle xor [[VAL_56]], [[VAL_7]], [[VAL_5]] : f32
// CHECK: [[VAL_59:%.*]] = arith.addf [[VAL_56]], [[VAL_57]] : f32 // CHECK: [[VAL_59:%.*]] = arith.addf [[VAL_56]], [[VAL_57]] : f32
// CHECK: [[VAL_60:%.*]], [[VAL_61:%.*]] = gpu.shuffle xor [[VAL_59]], [[VAL_8]], [[VAL_5]] : f32 // CHECK: [[VAL_60:%.*]], [[VAL_61:%.*]] = gpu.shuffle xor [[VAL_59]], [[VAL_8]], [[VAL_5]] : f32
// CHECK: [[VAL_62:%.*]] = arith.addf [[VAL_59]], [[VAL_60]] : f32 // CHECK: [[VAL_62:%.*]] = arith.addf [[VAL_59]], [[VAL_60]] : f32
// CHECK: [[VAL_63:%.*]], [[VAL_64:%.*]] = gpu.shuffle xor [[VAL_62]], [[VAL_9]], [[VAL_5]] : f32 // CHECK: [[VAL_63:%.*]], [[VAL_64:%.*]] = gpu.shuffle xor [[VAL_62]], [[VAL_9]], [[VAL_5]] : f32
// CHECK: [[VAL_65:%.*]] = arith.addf [[VAL_62]], [[VAL_63]] : f32 // CHECK: [[VAL_65:%.*]] = arith.addf [[VAL_62]], [[VAL_63]] : f32
// CHECK: [[VAL_66:%.*]], [[VAL_67:%.*]] = gpu.shuffle xor [[VAL_65]], [[VAL_10]], [[VAL_5]] : f32 // CHECK: [[VAL_66:%.*]], [[VAL_67:%.*]] = gpu.shuffle xor [[VAL_65]], [[VAL_10]], [[VAL_5]] : f32
// CHECK: [[VAL_68:%.*]] = arith.addf [[VAL_65]], [[VAL_66]] : f32 // CHECK: [[VAL_68:%.*]] = arith.addf [[VAL_65]], [[VAL_66]] : f32
// CHECK: br ^bb18([[VAL_68]] : f32) // CHECK: cf.br ^bb18([[VAL_68]] : f32)
// CHECK: ^bb18([[VAL_69:%.*]]: f32): // CHECK: ^bb18([[VAL_69:%.*]]: f32):
// CHECK: cond_br [[VAL_30]], ^bb19, ^bb20 // CHECK: cf.cond_br [[VAL_30]], ^bb19, ^bb20
// CHECK: ^bb19: // CHECK: ^bb19:
// CHECK: [[VAL_70:%.*]] = arith.divsi [[VAL_27]], [[VAL_5]] : i32 // CHECK: [[VAL_70:%.*]] = arith.divsi [[VAL_27]], [[VAL_5]] : i32
// CHECK: [[VAL_71:%.*]] = arith.index_cast [[VAL_70]] : i32 to index // CHECK: [[VAL_71:%.*]] = arith.index_cast [[VAL_70]] : i32 to index
// CHECK: store [[VAL_69]], [[VAL_1]]{{\[}}[[VAL_71]]] : memref<32xf32, 3> // CHECK: store [[VAL_69]], [[VAL_1]]{{\[}}[[VAL_71]]] : memref<32xf32, 3>
// CHECK: br ^bb21 // CHECK: cf.br ^bb21
// CHECK: ^bb20: // CHECK: ^bb20:
// CHECK: br ^bb21 // CHECK: cf.br ^bb21
// CHECK: ^bb21: // CHECK: ^bb21:
// CHECK: gpu.barrier // CHECK: gpu.barrier
// CHECK: [[VAL_72:%.*]] = arith.addi [[VAL_28]], [[VAL_2]] : i32 // CHECK: [[VAL_72:%.*]] = arith.addi [[VAL_28]], [[VAL_2]] : i32
// CHECK: [[VAL_73:%.*]] = arith.divsi [[VAL_72]], [[VAL_5]] : i32 // CHECK: [[VAL_73:%.*]] = arith.divsi [[VAL_72]], [[VAL_5]] : i32
// CHECK: [[VAL_74:%.*]] = arith.cmpi slt, [[VAL_27]], [[VAL_73]] : i32 // CHECK: [[VAL_74:%.*]] = arith.cmpi slt, [[VAL_27]], [[VAL_73]] : i32
// CHECK: cond_br [[VAL_74]], ^bb22, ^bb41 // CHECK: cf.cond_br [[VAL_74]], ^bb22, ^bb41
// CHECK: ^bb22: // CHECK: ^bb22:
// CHECK: [[VAL_75:%.*]] = arith.index_cast [[VAL_27]] : i32 to index // CHECK: [[VAL_75:%.*]] = arith.index_cast [[VAL_27]] : i32 to index
// CHECK: [[VAL_76:%.*]] = memref.load [[VAL_1]]{{\[}}[[VAL_75]]] : memref<32xf32, 3> // CHECK: [[VAL_76:%.*]] = memref.load [[VAL_1]]{{\[}}[[VAL_75]]] : memref<32xf32, 3>
// CHECK: [[VAL_77:%.*]] = arith.cmpi slt, [[VAL_73]], [[VAL_5]] : i32 // CHECK: [[VAL_77:%.*]] = arith.cmpi slt, [[VAL_73]], [[VAL_5]] : i32
// CHECK: cond_br [[VAL_77]], ^bb23, ^bb39 // CHECK: cf.cond_br [[VAL_77]], ^bb23, ^bb39
// CHECK: ^bb23: // CHECK: ^bb23:
// CHECK: [[VAL_78:%.*]], [[VAL_79:%.*]] = gpu.shuffle xor [[VAL_76]], [[VAL_6]], [[VAL_73]] : f32 // CHECK: [[VAL_78:%.*]], [[VAL_79:%.*]] = gpu.shuffle xor [[VAL_76]], [[VAL_6]], [[VAL_73]] : f32
// CHECK: cond_br [[VAL_79]], ^bb24, ^bb25 // CHECK: cf.cond_br [[VAL_79]], ^bb24, ^bb25
// CHECK: ^bb24: // CHECK: ^bb24:
// CHECK: [[VAL_80:%.*]] = arith.addf [[VAL_76]], [[VAL_78]] : f32 // CHECK: [[VAL_80:%.*]] = arith.addf [[VAL_76]], [[VAL_78]] : f32
// CHECK: br ^bb26([[VAL_80]] : f32) // CHECK: cf.br ^bb26([[VAL_80]] : f32)
// CHECK: ^bb25: // CHECK: ^bb25:
// CHECK: br ^bb26([[VAL_76]] : f32) // CHECK: cf.br ^bb26([[VAL_76]] : f32)
// CHECK: ^bb26([[VAL_81:%.*]]: f32): // CHECK: ^bb26([[VAL_81:%.*]]: f32):
// CHECK: [[VAL_82:%.*]], [[VAL_83:%.*]] = gpu.shuffle xor [[VAL_81]], [[VAL_7]], [[VAL_73]] : f32 // CHECK: [[VAL_82:%.*]], [[VAL_83:%.*]] = gpu.shuffle xor [[VAL_81]], [[VAL_7]], [[VAL_73]] : f32
// CHECK: cond_br [[VAL_83]], ^bb27, ^bb28 // CHECK: cf.cond_br [[VAL_83]], ^bb27, ^bb28
// CHECK: ^bb27: // CHECK: ^bb27:
// CHECK: [[VAL_84:%.*]] = arith.addf [[VAL_81]], [[VAL_82]] : f32 // CHECK: [[VAL_84:%.*]] = arith.addf [[VAL_81]], [[VAL_82]] : f32
// CHECK: br ^bb29([[VAL_84]] : f32) // CHECK: cf.br ^bb29([[VAL_84]] : f32)
// CHECK: ^bb28: // CHECK: ^bb28:
// CHECK: br ^bb29([[VAL_81]] : f32) // CHECK: cf.br ^bb29([[VAL_81]] : f32)
// CHECK: ^bb29([[VAL_85:%.*]]: f32): // CHECK: ^bb29([[VAL_85:%.*]]: f32):
// CHECK: [[VAL_86:%.*]], [[VAL_87:%.*]] = gpu.shuffle xor [[VAL_85]], [[VAL_8]], [[VAL_73]] : f32 // CHECK: [[VAL_86:%.*]], [[VAL_87:%.*]] = gpu.shuffle xor [[VAL_85]], [[VAL_8]], [[VAL_73]] : f32
// CHECK: cond_br [[VAL_87]], ^bb30, ^bb31 // CHECK: cf.cond_br [[VAL_87]], ^bb30, ^bb31
// CHECK: ^bb30: // CHECK: ^bb30:
// CHECK: [[VAL_88:%.*]] = arith.addf [[VAL_85]], [[VAL_86]] : f32 // CHECK: [[VAL_88:%.*]] = arith.addf [[VAL_85]], [[VAL_86]] : f32
// CHECK: br ^bb32([[VAL_88]] : f32) // CHECK: cf.br ^bb32([[VAL_88]] : f32)
// CHECK: ^bb31: // CHECK: ^bb31:
// CHECK: br ^bb32([[VAL_85]] : f32) // CHECK: cf.br ^bb32([[VAL_85]] : f32)
// CHECK: ^bb32([[VAL_89:%.*]]: f32): // CHECK: ^bb32([[VAL_89:%.*]]: f32):
// CHECK: [[VAL_90:%.*]], [[VAL_91:%.*]] = gpu.shuffle xor [[VAL_89]], [[VAL_9]], [[VAL_73]] : f32 // CHECK: [[VAL_90:%.*]], [[VAL_91:%.*]] = gpu.shuffle xor [[VAL_89]], [[VAL_9]], [[VAL_73]] : f32
// CHECK: cond_br [[VAL_91]], ^bb33, ^bb34 // CHECK: cf.cond_br [[VAL_91]], ^bb33, ^bb34
// CHECK: ^bb33: // CHECK: ^bb33:
// CHECK: [[VAL_92:%.*]] = arith.addf [[VAL_89]], [[VAL_90]] : f32 // CHECK: [[VAL_92:%.*]] = arith.addf [[VAL_89]], [[VAL_90]] : f32
// CHECK: br ^bb35([[VAL_92]] : f32) // CHECK: cf.br ^bb35([[VAL_92]] : f32)
// CHECK: ^bb34: // CHECK: ^bb34:
// CHECK: br ^bb35([[VAL_89]] : f32) // CHECK: cf.br ^bb35([[VAL_89]] : f32)
// CHECK: ^bb35([[VAL_93:%.*]]: f32): // CHECK: ^bb35([[VAL_93:%.*]]: f32):
// CHECK: [[VAL_94:%.*]], [[VAL_95:%.*]] = gpu.shuffle xor [[VAL_93]], [[VAL_10]], [[VAL_73]] : f32 // CHECK: [[VAL_94:%.*]], [[VAL_95:%.*]] = gpu.shuffle xor [[VAL_93]], [[VAL_10]], [[VAL_73]] : f32
// CHECK: cond_br [[VAL_95]], ^bb36, ^bb37 // CHECK: cf.cond_br [[VAL_95]], ^bb36, ^bb37
// CHECK: ^bb36: // CHECK: ^bb36:
// CHECK: [[VAL_96:%.*]] = arith.addf [[VAL_93]], [[VAL_94]] : f32 // CHECK: [[VAL_96:%.*]] = arith.addf [[VAL_93]], [[VAL_94]] : f32
// CHECK: br ^bb38([[VAL_96]] : f32) // CHECK: cf.br ^bb38([[VAL_96]] : f32)
// CHECK: ^bb37: // CHECK: ^bb37:
// CHECK: br ^bb38([[VAL_93]] : f32) // CHECK: cf.br ^bb38([[VAL_93]] : f32)
// CHECK: ^bb38([[VAL_97:%.*]]: f32): // CHECK: ^bb38([[VAL_97:%.*]]: f32):
// CHECK: br ^bb40([[VAL_97]] : f32) // CHECK: cf.br ^bb40([[VAL_97]] : f32)
// CHECK: ^bb39: // CHECK: ^bb39:
// CHECK: [[VAL_98:%.*]], [[VAL_99:%.*]] = gpu.shuffle xor [[VAL_76]], [[VAL_6]], [[VAL_5]] : f32 // CHECK: [[VAL_98:%.*]], [[VAL_99:%.*]] = gpu.shuffle xor [[VAL_76]], [[VAL_6]], [[VAL_5]] : f32
// CHECK: [[VAL_100:%.*]] = arith.addf [[VAL_76]], [[VAL_98]] : f32 // CHECK: [[VAL_100:%.*]] = arith.addf [[VAL_76]], [[VAL_98]] : f32
// CHECK: [[VAL_101:%.*]], [[VAL_102:%.*]] = gpu.shuffle xor [[VAL_100]], [[VAL_7]], [[VAL_5]] : f32 // CHECK: [[VAL_101:%.*]], [[VAL_102:%.*]] = gpu.shuffle xor [[VAL_100]], [[VAL_7]], [[VAL_5]] : f32
// CHECK: [[VAL_103:%.*]] = arith.addf [[VAL_100]], [[VAL_101]] : f32 // CHECK: [[VAL_103:%.*]] = arith.addf [[VAL_100]], [[VAL_101]] : f32
// CHECK: [[VAL_104:%.*]], [[VAL_105:%.*]] = gpu.shuffle xor [[VAL_103]], [[VAL_8]], [[VAL_5]] : f32 // CHECK: [[VAL_104:%.*]], [[VAL_105:%.*]] = gpu.shuffle xor [[VAL_103]], [[VAL_8]], [[VAL_5]] : f32
// CHECK: [[VAL_106:%.*]] = arith.addf [[VAL_103]], [[VAL_104]] : f32 // CHECK: [[VAL_106:%.*]] = arith.addf [[VAL_103]], [[VAL_104]] : f32
// CHECK: [[VAL_107:%.*]], [[VAL_108:%.*]] = gpu.shuffle xor [[VAL_106]], [[VAL_9]], [[VAL_5]] : f32 // CHECK: [[VAL_107:%.*]], [[VAL_108:%.*]] = gpu.shuffle xor [[VAL_106]], [[VAL_9]], [[VAL_5]] : f32
// CHECK: [[VAL_109:%.*]] = arith.addf [[VAL_106]], [[VAL_107]] : f32 // CHECK: [[VAL_109:%.*]] = arith.addf [[VAL_106]], [[VAL_107]] : f32
// CHECK: [[VAL_110:%.*]], [[VAL_111:%.*]] = gpu.shuffle xor [[VAL_109]], [[VAL_10]], [[VAL_5]] : f32 // CHECK: [[VAL_110:%.*]], [[VAL_111:%.*]] = gpu.shuffle xor [[VAL_109]], [[VAL_10]], [[VAL_5]] : f32
// CHECK: [[VAL_112:%.*]] = arith.addf [[VAL_109]], [[VAL_110]] : f32 // CHECK: [[VAL_112:%.*]] = arith.addf [[VAL_109]], [[VAL_110]] : f32
// CHECK: br ^bb40([[VAL_112]] : f32) // CHECK: cf.br ^bb40([[VAL_112]] : f32)
// CHECK: ^bb40([[VAL_113:%.*]]: f32): // CHECK: ^bb40([[VAL_113:%.*]]: f32):
// CHECK: store [[VAL_113]], [[VAL_1]]{{\[}}[[VAL_4]]] : memref<32xf32, 3> // CHECK: store [[VAL_113]], [[VAL_1]]{{\[}}[[VAL_4]]] : memref<32xf32, 3>
// CHECK: br ^bb42 // CHECK: cf.br ^bb42
// CHECK: ^bb41: // CHECK: ^bb41:
// CHECK: br ^bb42 // CHECK: cf.br ^bb42
// CHECK: ^bb42: // CHECK: ^bb42:
// CHECK: gpu.barrier // CHECK: gpu.barrier
%sum = gpu.all_reduce add %arg0 {} : (f32) -> (f32) %sum = gpu.all_reduce add %arg0 {} : (f32) -> (f32)
gpu.return gpu.return
} }
} }

mlir/test/Dialect/GPU/outlining.mlir

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
// CHECK-NEXT: = gpu.thread_id y // CHECK-NEXT: = gpu.thread_id y
// CHECK-NEXT: = gpu.thread_id z // CHECK-NEXT: = gpu.thread_id z
// CHECK-NEXT: = gpu.grid_dim x // CHECK-NEXT: = gpu.grid_dim x
// CHECK-NEXT: = gpu.grid_dim y // CHECK-NEXT: = gpu.grid_dim y
// CHECK-NEXT: = gpu.grid_dim z // CHECK-NEXT: = gpu.grid_dim z
// CHECK-NEXT: %[[BDIM:.*]] = gpu.block_dim x // CHECK-NEXT: %[[BDIM:.*]] = gpu.block_dim x
// CHECK-NEXT: = gpu.block_dim y // CHECK-NEXT: = gpu.block_dim y
// CHECK-NEXT: = gpu.block_dim z // CHECK-NEXT: = gpu.block_dim z
// CHECK-NEXT: br ^[[BLOCK:.*]] // CHECK-NEXT: cf.br ^[[BLOCK:.*]]
// CHECK-NEXT: ^[[BLOCK]]: // CHECK-NEXT: ^[[BLOCK]]:
// CHECK-NEXT: "use"(%[[KERNEL_ARG0]]) : (f32) -> () // CHECK-NEXT: "use"(%[[KERNEL_ARG0]]) : (f32) -> ()
// CHECK-NEXT: "some_op"(%[[BID]], %[[BDIM]]) : (index, index) -> () // CHECK-NEXT: "some_op"(%[[BID]], %[[BDIM]]) : (index, index) -> ()
// CHECK-NEXT: = memref.load %[[KERNEL_ARG1]][%[[TID]]] : memref<?xf32, 1> // CHECK-NEXT: = memref.load %[[KERNEL_ARG1]][%[[TID]]] : memref<?xf32, 1>
// ----- // -----
// CHECK: module attributes {gpu.container_module} // CHECK: module attributes {gpu.container_module}
▲ Show 20 Lines • Show All 209 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/canonicalize.mlir

Show First 20 Lines • Show All 202 Lines • ▼ Show 20 Lines
#map = affine_map<(d0, d1) -> (d0, d1)> #map = affine_map<(d0, d1) -> (d0, d1)>
func @keep_not_noop(%arg0 : tensor<?x?xf32>) -> tensor<?x?xf32> { func @keep_not_noop(%arg0 : tensor<?x?xf32>) -> tensor<?x?xf32> {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%cst = arith.constant 1.000000e+00 : f32 %cst = arith.constant 1.000000e+00 : f32
%0 = tensor.dim %arg0, %c0 : tensor<?x?xf32> %0 = tensor.dim %arg0, %c0 : tensor<?x?xf32>
%1 = tensor.dim %arg0, %c1 : tensor<?x?xf32> %1 = tensor.dim %arg0, %c1 : tensor<?x?xf32>
%2 = linalg.init_tensor [%0, %1] : tensor<?x?xf32> %2 = linalg.init_tensor [%0, %1] : tensor<?x?xf32>
br ^bb1(%cst : f32) cf.br ^bb1(%cst : f32)
^bb1(%arg1 : f32): ^bb1(%arg1 : f32):
%3 = linalg.generic %3 = linalg.generic
{indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]}
ins(%arg0 : tensor<?x?xf32>) outs(%2 : tensor<?x?xf32>) { ins(%arg0 : tensor<?x?xf32>) outs(%2 : tensor<?x?xf32>) {
^bb0(%arg2: f32, %arg3 : f32): ^bb0(%arg2: f32, %arg3 : f32):
linalg.yield %arg1 : f32 linalg.yield %arg1 : f32
} -> tensor<?x?xf32> } -> tensor<?x?xf32>
Show All 9 Lines
func @keep_not_noop(%arg0 : tensor<?x?xf32>, %arg1 : tensor<?x?xf32>) func @keep_not_noop(%arg0 : tensor<?x?xf32>, %arg1 : tensor<?x?xf32>)
-> (tensor<?x?xf32>, tensor<?x?xf32>) { -> (tensor<?x?xf32>, tensor<?x?xf32>) {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%cst = arith.constant 1.000000e+00 : f32 %cst = arith.constant 1.000000e+00 : f32
%0 = tensor.dim %arg0, %c0 : tensor<?x?xf32> %0 = tensor.dim %arg0, %c0 : tensor<?x?xf32>
%1 = tensor.dim %arg0, %c1 : tensor<?x?xf32> %1 = tensor.dim %arg0, %c1 : tensor<?x?xf32>
%2 = linalg.init_tensor [%0, %1] : tensor<?x?xf32> %2 = linalg.init_tensor [%0, %1] : tensor<?x?xf32>
br ^bb1(%cst : f32) cf.br ^bb1(%cst : f32)
^bb1(%arg2 : f32): ^bb1(%arg2 : f32):
%3:2 = linalg.generic %3:2 = linalg.generic
{indexing_maps = [#map, #map, #map, #map], {indexing_maps = [#map, #map, #map, #map],
iterator_types = ["parallel", "parallel"]} iterator_types = ["parallel", "parallel"]}
ins(%arg0, %arg1 : tensor<?x?xf32>, tensor<?x?xf32>) ins(%arg0, %arg1 : tensor<?x?xf32>, tensor<?x?xf32>)
outs(%2, %2 : tensor<?x?xf32>, tensor<?x?xf32>) { outs(%2, %2 : tensor<?x?xf32>, tensor<?x?xf32>) {
^bb0(%arg3: f32, %arg4 : f32, %arg5 : f32, %arg6 : f32): ^bb0(%arg3: f32, %arg4 : f32, %arg5 : f32, %arg6 : f32):
▲ Show 20 Lines • Show All 342 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/comprehensive-module-bufferize-invalid.mlir

Show All 14 Lines
func private @foo() -> tensor<?xf32> func private @foo() -> tensor<?xf32>
// ----- // -----
// expected-error @+1 {{cannot bufferize a FuncOp with tensors and without a unique ReturnOp}} // expected-error @+1 {{cannot bufferize a FuncOp with tensors and without a unique ReturnOp}}
func @swappy(%cond1 : i1, %cond2 : i1, %t1 : tensor<f32>, %t2 : tensor<f32>) func @swappy(%cond1 : i1, %cond2 : i1, %t1 : tensor<f32>, %t2 : tensor<f32>)
-> (tensor<f32>, tensor<f32>) -> (tensor<f32>, tensor<f32>)
{ {
cond_br %cond1, ^bb1, ^bb2 cf.cond_br %cond1, ^bb1, ^bb2
^bb1: ^bb1:
%T:2 = scf.if %cond2 -> (tensor<f32>, tensor<f32>) { %T:2 = scf.if %cond2 -> (tensor<f32>, tensor<f32>) {
scf.yield %t1, %t2 : tensor<f32>, tensor<f32> scf.yield %t1, %t2 : tensor<f32>, tensor<f32>
} else { } else {
scf.yield %t2, %t1 : tensor<f32>, tensor<f32> scf.yield %t2, %t1 : tensor<f32>, tensor<f32>
} }
return %T#0, %T#1 : tensor<f32>, tensor<f32> return %T#0, %T#1 : tensor<f32>, tensor<f32>
▲ Show 20 Lines • Show All 233 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/detensorize_br_operands.mlir

Show All 11 Lines %3 = linalg.generic
ins(%arg0_t : tensor<i1>) ins(%arg0_t : tensor<i1>)
outs(%2 : tensor<i8>) { outs(%2 : tensor<i8>) {
^bb0(%arg2: i1, %arg3: i8): ^bb0(%arg2: i1, %arg3: i8):
%10 = arith.extui %arg2 : i1 to i8 %10 = arith.extui %arg2 : i1 to i8
linalg.yield %10 : i8 linalg.yield %10 : i8
} -> tensor<i8> } -> tensor<i8>
%4 = tensor.extract %3[] : tensor<i8> %4 = tensor.extract %3[] : tensor<i8>
%5 = arith.trunci %4 : i8 to i1 %5 = arith.trunci %4 : i8 to i1
cond_br %5, ^bb1, ^bb2(%arg1_t : tensor<i32>) cf.cond_br %5, ^bb1, ^bb2(%arg1_t : tensor<i32>)
^bb1: ^bb1:
%6 = linalg.init_tensor [] : tensor<i32> %6 = linalg.init_tensor [] : tensor<i32>
%7 = linalg.generic %7 = linalg.generic
{indexing_maps = [affine_map<() -> ()>, affine_map<() -> ()>, affine_map<() -> ()>], iterator_types = []} {indexing_maps = [affine_map<() -> ()>, affine_map<() -> ()>, affine_map<() -> ()>], iterator_types = []}
ins(%arg1_t, %cst : tensor<i32>, tensor<i32>) ins(%arg1_t, %cst : tensor<i32>, tensor<i32>)
outs(%6 : tensor<i32>) { outs(%6 : tensor<i32>) {
^bb0(%arg2: i32, %arg3: i32, %arg4: i32): ^bb0(%arg2: i32, %arg3: i32, %arg4: i32):
%10 = arith.addi %arg2, %arg3 : i32 %10 = arith.addi %arg2, %arg3 : i32
linalg.yield %10 : i32 linalg.yield %10 : i32
} -> tensor<i32> } -> tensor<i32>
br ^bb2(%7 : tensor<i32>) cf.br ^bb2(%7 : tensor<i32>)
^bb2(%8: tensor<i32>): ^bb2(%8: tensor<i32>):
return %8 : tensor<i32> return %8 : tensor<i32>
} }
// CHECK-LABEL: func @if_true_test // CHECK-LABEL: func @if_true_test
// CHECK-SAME: (%[[arg0:.*]]: i1, %[[arg1:.*]]: i32) // CHECK-SAME: (%[[arg0:.*]]: i1, %[[arg1:.*]]: i32)
// CHECK-NEXT: arith.constant 10 : i32 // CHECK-NEXT: arith.constant 10 : i32
// CHECK-NEXT: cond_br %[[arg0]], ^[[bb1:.*]], ^[[bb2:.*]](%[[arg1]] : i32) // CHECK-NEXT: cf.cond_br %[[arg0]], ^[[bb1:.*]], ^[[bb2:.*]](%[[arg1]] : i32)
// CHECK-NEXT: ^[[bb1]]: // CHECK-NEXT: ^[[bb1]]:
// CHECK-NEXT: %[[add_res:.*]] = arith.addi // CHECK-NEXT: %[[add_res:.*]] = arith.addi
// CHECK-NEXT: br ^[[bb2]](%[[add_res]] : i32) // CHECK-NEXT: cf.br ^[[bb2]](%[[add_res]] : i32)
// CHECK-NEXT: ^[[bb2]] // CHECK-NEXT: ^[[bb2]]
// CHECK-NEXT: %[[func_res:.*]] = tensor.from_elements // CHECK-NEXT: %[[func_res:.*]] = tensor.from_elements
// CHECK-NEXT: return %[[func_res]] // CHECK-NEXT: return %[[func_res]]

mlir/test/Dialect/Linalg/detensorize_if.mlir

// RUN: mlir-opt %s -split-input-file -allow-unregistered-dialect -pass-pipeline="builtin.func(linalg-detensorize)" | FileCheck %s // RUN: mlir-opt %s -split-input-file -allow-unregistered-dialect -pass-pipeline="builtin.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 = []
} }
func @main() -> (tensor<i32>) attributes {} { func @main() -> (tensor<i32>) attributes {} {
%c0 = arith.constant 0 : i32 %c0 = arith.constant 0 : i32
%0 = tensor.from_elements %c0 : tensor<i32> %0 = tensor.from_elements %c0 : tensor<i32>
%c10 = arith.constant 10 : i32 %c10 = arith.constant 10 : i32
%1 = tensor.from_elements %c10 : tensor<i32> %1 = tensor.from_elements %c10 : tensor<i32>
br ^bb1(%0 : tensor<i32>) cf.br ^bb1(%0 : tensor<i32>)
^bb1(%2: tensor<i32>): // 2 preds: ^bb0, ^bb2 ^bb1(%2: tensor<i32>): // 2 preds: ^bb0, ^bb2
%3 = linalg.init_tensor [] : tensor<i1> %3 = linalg.init_tensor [] : tensor<i1>
%4 = linalg.generic #attrs %4 = linalg.generic #attrs
ins(%2, %1 : tensor<i32>, tensor<i32>) ins(%2, %1 : tensor<i32>, tensor<i32>)
outs(%3 : tensor<i1>) { outs(%3 : tensor<i1>) {
^bb0(%arg0: i32, %arg1: i32, %arg2: i1): ^bb0(%arg0: i32, %arg1: i32, %arg2: i1):
%8 = arith.cmpi slt, %arg0, %arg1 : i32 %8 = arith.cmpi slt, %arg0, %arg1 : i32
linalg.yield %8 : i1 linalg.yield %8 : i1
} -> tensor<i1> } -> tensor<i1>
%5 = tensor.extract %4[] : tensor<i1> %5 = tensor.extract %4[] : tensor<i1>
cond_br %5, ^bb2(%2 : tensor<i32>), ^bb3(%2 : tensor<i32>) cf.cond_br %5, ^bb2(%2 : tensor<i32>), ^bb3(%2 : tensor<i32>)
^bb2(%6: tensor<i32>): // pred: ^bb1 ^bb2(%6: tensor<i32>): // pred: ^bb1
%7 = linalg.init_tensor [] : tensor<i32> %7 = linalg.init_tensor [] : tensor<i32>
%8 = linalg.generic #attrs %8 = linalg.generic #attrs
ins(%6, %6 : tensor<i32>, tensor<i32>) ins(%6, %6 : tensor<i32>, tensor<i32>)
outs(%7 : tensor<i32>) { outs(%7 : tensor<i32>) {
^bb0(%arg0: i32, %arg1: i32, %arg2: i32): ^bb0(%arg0: i32, %arg1: i32, %arg2: i32):
%9 = arith.addi %arg0, %arg1 : i32 %9 = arith.addi %arg0, %arg1 : i32
linalg.yield %9 : i32 linalg.yield %9 : i32
} -> tensor<i32> } -> tensor<i32>
br ^bb3(%8 : tensor<i32>) cf.br ^bb3(%8 : tensor<i32>)
^bb3(%10: tensor<i32>): // pred: ^bb1 ^bb3(%10: tensor<i32>): // pred: ^bb1
return %10 : tensor<i32> return %10 : tensor<i32>
} }
// CHECK-LABEL: func @main() // CHECK-LABEL: func @main()
// CHECK-NEXT: arith.constant 0 // CHECK-NEXT: arith.constant 0
// CHECK-NEXT: arith.constant 10 // CHECK-NEXT: arith.constant 10
// CHECK-NEXT: br ^[[bb1:.*]](%{{.*}}: i32) // CHECK-NEXT: cf.br ^[[bb1:.*]](%{{.*}}: i32)
// CHECK-NEXT: ^[[bb1]](%{{.*}}: i32): // CHECK-NEXT: ^[[bb1]](%{{.*}}: i32):
// CHECK-NEXT: arith.cmpi slt, %{{.*}}, %{{.*}} // CHECK-NEXT: arith.cmpi slt, %{{.*}}, %{{.*}}
// CHECK-NEXT: cond_br %{{.*}}, ^[[bb2:.*]](%{{.*}} : i32), ^bb3(%{{.*}} : i32) // CHECK-NEXT: cf.cond_br %{{.*}}, ^[[bb2:.*]](%{{.*}} : i32), ^bb3(%{{.*}} : i32)
// CHECK-NEXT: ^[[bb2]](%{{.*}}: i32) // CHECK-NEXT: ^[[bb2]](%{{.*}}: i32)
// CHECK-NEXT: arith.addi %{{.*}}, %{{.*}} // CHECK-NEXT: arith.addi %{{.*}}, %{{.*}}
// CHECK-NEXT: br ^[[bb3:.*]](%{{.*}} : i32) // CHECK-NEXT: cf.br ^[[bb3:.*]](%{{.*}} : i32)
// CHECK-NEXT: ^[[bb3]](%{{.*}}: i32) // CHECK-NEXT: ^[[bb3]](%{{.*}}: i32)
// CHECK-NEXT: tensor.from_elements %{{.*}} : tensor<i32> // CHECK-NEXT: tensor.from_elements %{{.*}} : tensor<i32>
// CHECK-NEXT: return %{{.*}} // CHECK-NEXT: return %{{.*}}
// CHECK-NEXT: } // CHECK-NEXT: }
// ----- // -----
// Similar to the above test with one change: one of the block after the // Similar to the above test with one change: one of the block after the
// if-condition passes/forwards its tensor argument to another block. // if-condition passes/forwards its tensor argument to another block.
#map0 = affine_map<() -> ()> #map0 = affine_map<() -> ()>
#attrs = { #attrs = {
indexing_maps = [#map0, #map0, #map0], indexing_maps = [#map0, #map0, #map0],
iterator_types = [] iterator_types = []
} }
func @main() -> (tensor<i32>) attributes {} { func @main() -> (tensor<i32>) attributes {} {
%c0 = arith.constant 0 : i32 %c0 = arith.constant 0 : i32
%0 = tensor.from_elements %c0 : tensor<i32> %0 = tensor.from_elements %c0 : tensor<i32>
%c10 = arith.constant 10 : i32 %c10 = arith.constant 10 : i32
%1 = tensor.from_elements %c10 : tensor<i32> %1 = tensor.from_elements %c10 : tensor<i32>
br ^bb1(%0 : tensor<i32>) cf.br ^bb1(%0 : tensor<i32>)
^bb1(%2: tensor<i32>): // 2 preds: ^bb0, ^bb2 ^bb1(%2: tensor<i32>): // 2 preds: ^bb0, ^bb2
%3 = linalg.init_tensor [] : tensor<i1> %3 = linalg.init_tensor [] : tensor<i1>
%4 = linalg.generic #attrs %4 = linalg.generic #attrs
ins(%2, %1 : tensor<i32>, tensor<i32>) ins(%2, %1 : tensor<i32>, tensor<i32>)
outs(%3 : tensor<i1>) { outs(%3 : tensor<i1>) {
^bb0(%arg0: i32, %arg1: i32, %arg2: i1): ^bb0(%arg0: i32, %arg1: i32, %arg2: i1):
%8 = arith.cmpi slt, %arg0, %arg1 : i32 %8 = arith.cmpi slt, %arg0, %arg1 : i32
linalg.yield %8 : i1 linalg.yield %8 : i1
} -> tensor<i1> } -> tensor<i1>
%5 = tensor.extract %4[] : tensor<i1> %5 = tensor.extract %4[] : tensor<i1>
cond_br %5, ^bb2(%2 : tensor<i32>), ^bb3(%2 : tensor<i32>) cf.cond_br %5, ^bb2(%2 : tensor<i32>), ^bb3(%2 : tensor<i32>)
^bb2(%6: tensor<i32>): // pred: ^bb1 ^bb2(%6: tensor<i32>): // pred: ^bb1
%7 = linalg.init_tensor [] : tensor<i32> %7 = linalg.init_tensor [] : tensor<i32>
%8 = linalg.generic #attrs %8 = linalg.generic #attrs
ins(%6, %6 : tensor<i32>, tensor<i32>) ins(%6, %6 : tensor<i32>, tensor<i32>)
outs(%7 : tensor<i32>) { outs(%7 : tensor<i32>) {
^bb0(%arg0: i32, %arg1: i32, %arg2: i32): ^bb0(%arg0: i32, %arg1: i32, %arg2: i32):
%9 = arith.addi %arg0, %arg1 : i32 %9 = arith.addi %arg0, %arg1 : i32
linalg.yield %9 : i32 linalg.yield %9 : i32
} -> tensor<i32> } -> tensor<i32>
br ^bb3(%8 : tensor<i32>) cf.br ^bb3(%8 : tensor<i32>)
^bb3(%10: tensor<i32>): // pred: ^bb1 ^bb3(%10: tensor<i32>): // pred: ^bb1
br ^bb4(%10 : tensor<i32>) cf.br ^bb4(%10 : tensor<i32>)
^bb4(%11: tensor<i32>): // pred: ^bb1 ^bb4(%11: tensor<i32>): // pred: ^bb1
return %11 : tensor<i32> return %11 : tensor<i32>
} }
// CHECK-LABEL: func @main() // CHECK-LABEL: func @main()
// CHECK-NEXT: arith.constant 0 // CHECK-NEXT: arith.constant 0
// CHECK-NEXT: arith.constant 10 // CHECK-NEXT: arith.constant 10
// CHECK-NEXT: br ^[[bb1:.*]](%{{.*}}: i32) // CHECK-NEXT: cf.br ^[[bb1:.*]](%{{.*}}: i32)
// CHECK-NEXT: ^[[bb1]](%{{.*}}: i32): // CHECK-NEXT: ^[[bb1]](%{{.*}}: i32):
// CHECK-NEXT: arith.cmpi slt, %{{.*}}, %{{.*}} // CHECK-NEXT: arith.cmpi slt, %{{.*}}, %{{.*}}
// CHECK-NEXT: cond_br %{{.*}}, ^[[bb2:.*]](%{{.*}} : i32), ^bb3(%{{.*}} : i32) // CHECK-NEXT: cf.cond_br %{{.*}}, ^[[bb2:.*]](%{{.*}} : i32), ^bb3(%{{.*}} : i32)
// CHECK-NEXT: ^[[bb2]](%{{.*}}: i32) // CHECK-NEXT: ^[[bb2]](%{{.*}}: i32)
// CHECK-NEXT: arith.addi %{{.*}}, %{{.*}} // CHECK-NEXT: arith.addi %{{.*}}, %{{.*}}
// CHECK-NEXT: br ^[[bb3:.*]](%{{.*}} : i32) // CHECK-NEXT: cf.br ^[[bb3:.*]](%{{.*}} : i32)
// CHECK-NEXT: ^[[bb3]](%{{.*}}: i32) // CHECK-NEXT: ^[[bb3]](%{{.*}}: i32)
// CHECK-NEXT: br ^[[bb4:.*]](%{{.*}} : i32) // CHECK-NEXT: cf.br ^[[bb4:.*]](%{{.*}} : i32)
// CHECK-NEXT: ^[[bb4]](%{{.*}}: i32) // CHECK-NEXT: ^[[bb4]](%{{.*}}: i32)
// CHECK-NEXT: tensor.from_elements %{{.*}} : tensor<i32> // CHECK-NEXT: tensor.from_elements %{{.*}} : tensor<i32>
// CHECK-NEXT: return %{{.*}} // CHECK-NEXT: return %{{.*}}
// CHECK-NEXT: } // CHECK-NEXT: }
// ----- // -----
#map0 = affine_map<() -> ()> #map0 = affine_map<() -> ()>
#attrs = { #attrs = {
indexing_maps = [#map0, #map0, #map0], indexing_maps = [#map0, #map0, #map0],
iterator_types = [] iterator_types = []
} }
func @main() -> (tensor<i32>) attributes {} { func @main() -> (tensor<i32>) attributes {} {
%c0 = arith.constant 0 : i32 %c0 = arith.constant 0 : i32
%0 = tensor.from_elements %c0 : tensor<i32> %0 = tensor.from_elements %c0 : tensor<i32>
%c10 = arith.constant 10 : i32 %c10 = arith.constant 10 : i32
%1 = tensor.from_elements %c10 : tensor<i32> %1 = tensor.from_elements %c10 : tensor<i32>
br ^bb1(%0 : tensor<i32>) cf.br ^bb1(%0 : tensor<i32>)
^bb1(%2: tensor<i32>): // 2 preds: ^bb0, ^bb2 ^bb1(%2: tensor<i32>): // 2 preds: ^bb0, ^bb2
%3 = linalg.init_tensor [] : tensor<i1> %3 = linalg.init_tensor [] : tensor<i1>
%4 = linalg.generic #attrs %4 = linalg.generic #attrs
ins(%2, %1 : tensor<i32>, tensor<i32>) ins(%2, %1 : tensor<i32>, tensor<i32>)
outs(%3 : tensor<i1>) { outs(%3 : tensor<i1>) {
^bb0(%arg0: i32, %arg1: i32, %arg2: i1): ^bb0(%arg0: i32, %arg1: i32, %arg2: i1):
%8 = arith.cmpi slt, %arg0, %arg1 : i32 %8 = arith.cmpi slt, %arg0, %arg1 : i32
linalg.yield %8 : i1 linalg.yield %8 : i1
} -> tensor<i1> } -> tensor<i1>
%5 = tensor.extract %4[] : tensor<i1> %5 = tensor.extract %4[] : tensor<i1>
// This cond_br intentionally has bb2 as it's target for both branches. This // This cf.cond_br intentionally has bb2 as it's target for both branches. This
// is to make sure that the "forward phase" of the cost-model correctly adds // is to make sure that the "forward phase" of the cost-model correctly adds
// the users of a block argument (in this case bb2's argument) to the work // the users of a block argument (in this case bb2's argument) to the work
// list. // list.
cond_br %5, ^bb2(%2 : tensor<i32>), ^bb2(%2 : tensor<i32>) cf.cond_br %5, ^bb2(%2 : tensor<i32>), ^bb2(%2 : tensor<i32>)
^bb2(%6: tensor<i32>): // pred: ^bb1 ^bb2(%6: tensor<i32>): // pred: ^bb1
%12 = tensor.from_elements %c10 : tensor<i32> %12 = tensor.from_elements %c10 : tensor<i32>
%7 = linalg.init_tensor [] : tensor<i32> %7 = linalg.init_tensor [] : tensor<i32>
%8 = linalg.generic #attrs %8 = linalg.generic #attrs
ins(%6, %12 : tensor<i32>, tensor<i32>) ins(%6, %12 : tensor<i32>, tensor<i32>)
outs(%7 : tensor<i32>) { outs(%7 : tensor<i32>) {
^bb0(%arg0: i32, %arg1: i32, %arg2: i32): ^bb0(%arg0: i32, %arg1: i32, %arg2: i32):
%9 = arith.addi %arg0, %arg1 : i32 %9 = arith.addi %arg0, %arg1 : i32
linalg.yield %9 : i32 linalg.yield %9 : i32
} -> tensor<i32> } -> tensor<i32>
br ^bb3(%8 : tensor<i32>) cf.br ^bb3(%8 : tensor<i32>)
^bb3(%10: tensor<i32>): // pred: ^bb1 ^bb3(%10: tensor<i32>): // pred: ^bb1
return %10 : tensor<i32> return %10 : tensor<i32>
} }
// CHECK-LABEL: func @main() // CHECK-LABEL: func @main()
// CHECK-NEXT: arith.constant 0 // CHECK-NEXT: arith.constant 0
// CHECK-NEXT: arith.constant 10 // CHECK-NEXT: arith.constant 10
// CHECK-NEXT: br ^[[bb1:.*]](%{{.*}}: i32) // CHECK-NEXT: cf.br ^[[bb1:.*]](%{{.*}}: i32)
// CHECK-NEXT: ^[[bb1]](%{{.*}}: i32): // CHECK-NEXT: ^[[bb1]](%{{.*}}: i32):
// CHECK-NEXT: arith.cmpi slt, %{{.*}}, %{{.*}} // CHECK-NEXT: arith.cmpi slt, %{{.*}}, %{{.*}}
// CHECK-NEXT: cond_br %{{.*}}, ^[[bb2:.*]](%{{.*}} : i32), ^bb2(%{{.*}} : i32) // CHECK-NEXT: cf.cond_br %{{.*}}, ^[[bb2:.*]](%{{.*}} : i32), ^bb2(%{{.*}} : i32)
// CHECK-NEXT: ^[[bb2]](%{{.*}}: i32) // CHECK-NEXT: ^[[bb2]](%{{.*}}: i32)
// CHECK-NEXT: arith.addi %{{.*}}, %{{.*}} // CHECK-NEXT: arith.addi %{{.*}}, %{{.*}}
// CHECK-NEXT: br ^[[bb3:.*]](%{{.*}} : i32) // CHECK-NEXT: cf.br ^[[bb3:.*]](%{{.*}} : i32)
// CHECK-NEXT: ^[[bb3]](%{{.*}}: i32) // CHECK-NEXT: ^[[bb3]](%{{.*}}: i32)
// CHECK-NEXT: tensor.from_elements %{{.*}} : tensor<i32> // CHECK-NEXT: tensor.from_elements %{{.*}} : tensor<i32>
// CHECK-NEXT: return %{{.*}} // CHECK-NEXT: return %{{.*}}
// CHECK-NEXT: } // CHECK-NEXT: }

mlir/test/Dialect/Linalg/detensorize_while.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.func(linalg-detensorize{aggressive-mode})" | FileCheck %s -check-prefix=DET-ALL // RUN: mlir-opt %s -pass-pipeline="builtin.func(linalg-detensorize{aggressive-mode})" | FileCheck %s -check-prefix=DET-ALL
// RUN: mlir-opt %s -pass-pipeline="builtin.func(linalg-detensorize)" | FileCheck %s -check-prefix=DET-CF // RUN: mlir-opt %s -pass-pipeline="builtin.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 = []
} }
func @main(%farg0: tensor<i32>, %farg1: tensor<i32>) -> tensor<i32> attributes {} { func @main(%farg0: tensor<i32>, %farg1: tensor<i32>) -> tensor<i32> attributes {} {
br ^bb1(%farg0 : tensor<i32>) cf.br ^bb1(%farg0 : tensor<i32>)
^bb1(%0: tensor<i32>): // 2 preds: ^bb0, ^bb2 ^bb1(%0: tensor<i32>): // 2 preds: ^bb0, ^bb2
%1 = linalg.init_tensor [] : tensor<i1> %1 = linalg.init_tensor [] : tensor<i1>
%2 = linalg.generic #attrs %2 = linalg.generic #attrs
ins(%0, %farg1 : tensor<i32>, tensor<i32>) ins(%0, %farg1 : tensor<i32>, tensor<i32>)
outs(%1 : tensor<i1>) { outs(%1 : tensor<i1>) {
^bb0(%arg0: i32, %arg1: i32, %arg2: i1): ^bb0(%arg0: i32, %arg1: i32, %arg2: i1):
%8 = arith.cmpi slt, %arg0, %arg1 : i32 %8 = arith.cmpi slt, %arg0, %arg1 : i32
linalg.yield %8 : i1 linalg.yield %8 : i1
} -> tensor<i1> } -> tensor<i1>
%3 = tensor.extract %2[] : tensor<i1> %3 = tensor.extract %2[] : tensor<i1>
cond_br %3, ^bb2(%0 : tensor<i32>), ^bb3(%0 : tensor<i32>) cf.cond_br %3, ^bb2(%0 : tensor<i32>), ^bb3(%0 : tensor<i32>)
^bb2(%4: tensor<i32>): // pred: ^bb1 ^bb2(%4: tensor<i32>): // pred: ^bb1
%5 = linalg.init_tensor [] : tensor<i32> %5 = linalg.init_tensor [] : tensor<i32>
%6 = linalg.generic #attrs %6 = linalg.generic #attrs
ins(%4, %4 : tensor<i32>, tensor<i32>) ins(%4, %4 : tensor<i32>, tensor<i32>)
outs(%5 : tensor<i32>) { outs(%5 : tensor<i32>) {
^bb0(%arg0: i32, %arg1: i32, %arg2: i32): ^bb0(%arg0: i32, %arg1: i32, %arg2: i32):
%8 = arith.addi %arg0, %arg1 : i32 %8 = arith.addi %arg0, %arg1 : i32
linalg.yield %8 : i32 linalg.yield %8 : i32
} -> tensor<i32> } -> tensor<i32>
br ^bb1(%6 : tensor<i32>) cf.br ^bb1(%6 : tensor<i32>)
^bb3(%7: tensor<i32>): // pred: ^bb1 ^bb3(%7: tensor<i32>): // pred: ^bb1
return %7 : tensor<i32> return %7 : tensor<i32>
} }
// Test aggresively detensoring all detensorable ops. // Test aggresively detensoring all detensorable ops.
// //
// DET-ALL-LABEL: func @main // DET-ALL-LABEL: func @main
// DET-ALL-SAME: (%{{.*}}: tensor<i32>, %{{.*}}: tensor<i32>) // DET-ALL-SAME: (%{{.*}}: tensor<i32>, %{{.*}}: tensor<i32>)
// DET-ALL: tensor.extract {{.*}} // DET-ALL: tensor.extract {{.*}}
// DET-ALL: br ^[[bb1:.*]](%{{.*}} : i32) // DET-ALL: cf.br ^[[bb1:.*]](%{{.*}} : i32)
// DET-ALL: ^[[bb1]](%{{.*}}: i32) // DET-ALL: ^[[bb1]](%{{.*}}: i32)
// DET-ALL: arith.cmpi slt, {{.*}} // DET-ALL: arith.cmpi slt, {{.*}}
// DET-ALL: cond_br {{.*}}, ^[[bb2:.*]](%{{.*}} : i32), ^[[bb3:.*]](%{{.*}} : i32) // DET-ALL: cf.cond_br {{.*}}, ^[[bb2:.*]](%{{.*}} : i32), ^[[bb3:.*]](%{{.*}} : i32)
// DET-ALL: ^[[bb2]](%{{.*}}: i32) // DET-ALL: ^[[bb2]](%{{.*}}: i32)
// DET-ALL: arith.addi {{.*}} // DET-ALL: arith.addi {{.*}}
// DET-ALL: br ^[[bb1]](%{{.*}} : i32) // DET-ALL: cf.br ^[[bb1]](%{{.*}} : i32)
// DET-ALL: ^[[bb3]](%{{.*}}: i32) // DET-ALL: ^[[bb3]](%{{.*}}: i32)
// DET-ALL: tensor.from_elements {{.*}} // DET-ALL: tensor.from_elements {{.*}}
// DET-ALL: return %{{.*}} : tensor<i32> // DET-ALL: return %{{.*}} : tensor<i32>
// Test detensoring only ops involed in control-flow. // Test detensoring only ops involed in control-flow.
// //
// DET-CF-LABEL: func @main // DET-CF-LABEL: func @main
// DET-CF-SAME: (%{{.*}}: tensor<i32>, %{{.*}}: tensor<i32>) // DET-CF-SAME: (%{{.*}}: tensor<i32>, %{{.*}}: tensor<i32>)
// DET-CF: tensor.extract {{.*}} // DET-CF: tensor.extract {{.*}}
// DET-CF: br ^[[bb1:.*]](%{{.*}} : i32) // DET-CF: cf.br ^[[bb1:.*]](%{{.*}} : i32)
// DET-CF: ^[[bb1]](%{{.*}}: i32) // DET-CF: ^[[bb1]](%{{.*}}: i32)
// DET-CF: arith.cmpi slt, {{.*}} // DET-CF: arith.cmpi slt, {{.*}}
// DET-CF: cond_br {{.*}}, ^[[bb2:.*]](%{{.*}} : i32), ^[[bb3:.*]](%{{.*}} : i32) // DET-CF: cf.cond_br {{.*}}, ^[[bb2:.*]](%{{.*}} : i32), ^[[bb3:.*]](%{{.*}} : i32)
// DET-CF: ^[[bb2]](%{{.*}}: i32) // DET-CF: ^[[bb2]](%{{.*}}: i32)
// DET-CF: arith.addi {{.*}} // DET-CF: arith.addi {{.*}}
// DET-CF: br ^[[bb1]](%{{.*}} : i32) // DET-CF: cf.br ^[[bb1]](%{{.*}} : i32)
// DET-CF: ^[[bb3]](%{{.*}}: i32) // DET-CF: ^[[bb3]](%{{.*}}: i32)
// DET-CF: tensor.from_elements %{{.*}} : tensor<i32> // DET-CF: tensor.from_elements %{{.*}} : tensor<i32>
// DET-CF: return %{{.*}} : tensor<i32> // DET-CF: return %{{.*}} : tensor<i32>

mlir/test/Dialect/Linalg/detensorize_while_impure_cf.mlir

Show All 16 Lines
#broadcast_attrs = { #broadcast_attrs = {
indexing_maps = [#map1, #map2], indexing_maps = [#map1, #map2],
iterator_types = ["parallel"] iterator_types = ["parallel"]
} }
func @main(%farg0: tensor<10xi32>, %farg1: tensor<i32>) -> tensor<i32> attributes {} { func @main(%farg0: tensor<10xi32>, %farg1: tensor<i32>) -> tensor<i32> attributes {} {
br ^bb1(%farg0 : tensor<10xi32>) cf.br ^bb1(%farg0 : tensor<10xi32>)
^bb1(%0: tensor<10xi32>): // 2 preds: ^bb0, ^bb2 ^bb1(%0: tensor<10xi32>): // 2 preds: ^bb0, ^bb2
%1 = linalg.init_tensor [] : tensor<i32> %1 = linalg.init_tensor [] : tensor<i32>
%2 = linalg.generic #sum_reduction_attrs %2 = linalg.generic #sum_reduction_attrs
ins(%0: tensor<10xi32>) ins(%0: tensor<10xi32>)
outs(%1: tensor<i32>) { outs(%1: tensor<i32>) {
^bb(%a: i32, %x: i32): ^bb(%a: i32, %x: i32):
%b = arith.addi %x, %a : i32 %b = arith.addi %x, %a : i32
linalg.yield %b : i32 linalg.yield %b : i32
} -> tensor<i32> } -> tensor<i32>
%3 = linalg.init_tensor [] : tensor<i1> %3 = linalg.init_tensor [] : tensor<i1>
%4 = linalg.generic #attrs %4 = linalg.generic #attrs
ins(%2, %farg1 : tensor<i32>, tensor<i32>) ins(%2, %farg1 : tensor<i32>, tensor<i32>)
outs(%3 : tensor<i1>) { outs(%3 : tensor<i1>) {
^bb0(%arg0: i32, %arg1: i32, %arg2: i1): ^bb0(%arg0: i32, %arg1: i32, %arg2: i1):
%8 = arith.cmpi slt, %arg0, %arg1 : i32 %8 = arith.cmpi slt, %arg0, %arg1 : i32
linalg.yield %8 : i1 linalg.yield %8 : i1
} -> tensor<i1> } -> tensor<i1>
%5 = tensor.extract %4[] : tensor<i1> %5 = tensor.extract %4[] : tensor<i1>
cond_br %5, ^bb2(%2 : tensor<i32>), ^bb3(%2 : tensor<i32>) cf.cond_br %5, ^bb2(%2 : tensor<i32>), ^bb3(%2 : tensor<i32>)
^bb2(%6: tensor<i32>): // pred: ^bb1 ^bb2(%6: tensor<i32>): // pred: ^bb1
%7 = linalg.init_tensor [10] : tensor<10xi32> %7 = linalg.init_tensor [10] : tensor<10xi32>
%9 = linalg.generic #broadcast_attrs %9 = linalg.generic #broadcast_attrs
ins(%6: tensor<i32>) ins(%6: tensor<i32>)
outs(%7: tensor<10xi32>) { outs(%7: tensor<10xi32>) {
^bb(%a: i32, %b: i32) : ^bb(%a: i32, %b: i32) :
linalg.yield %a : i32 linalg.yield %a : i32
} -> tensor<10xi32> } -> tensor<10xi32>
br ^bb1(%9 : tensor<10xi32>) cf.br ^bb1(%9 : tensor<10xi32>)
^bb3(%10: tensor<i32>): // pred: ^bb1 ^bb3(%10: tensor<i32>): // pred: ^bb1
return %10 : tensor<i32> return %10 : tensor<i32>
} }
// Test aggresively detensoring all detensorable ops. // Test aggresively detensoring all detensorable ops.
// //
// DET-ALL-LABEL: func @main // DET-ALL-LABEL: func @main
// DET-ALL-SAME: (%{{.*}}: tensor<10xi32>, %{{.*}}: tensor<i32>) // DET-ALL-SAME: (%{{.*}}: tensor<10xi32>, %{{.*}}: tensor<i32>)
// DET-ALL: br ^[[bb1:.*]](%{{.*}} : tensor<10xi32>) // DET-ALL: cf.br ^[[bb1:.*]](%{{.*}} : tensor<10xi32>)
// DET-ALL: ^[[bb1]](%{{.*}}: tensor<10xi32>) // DET-ALL: ^[[bb1]](%{{.*}}: tensor<10xi32>)
// DET-ALL: linalg.init_tensor [] : tensor<i32> // DET-ALL: linalg.init_tensor [] : tensor<i32>
// DET-ALL: linalg.generic {{{.*}}} ins(%{{.*}} : tensor<10xi32>) outs(%{{.*}} : tensor<i32>) { // DET-ALL: linalg.generic {{{.*}}} ins(%{{.*}} : tensor<10xi32>) outs(%{{.*}} : tensor<i32>) {
// DET-ALL: ^bb0(%{{.*}}: i32, %{{.*}}: i32): // DET-ALL: ^bb0(%{{.*}}: i32, %{{.*}}: i32):
// DET-ALL: %{{.*}} = arith.addi %{{.*}}, %{{.*}} // DET-ALL: %{{.*}} = arith.addi %{{.*}}, %{{.*}}
// DET-ALL: linalg.yield %{{.*}} : i32 // DET-ALL: linalg.yield %{{.*}} : i32
// DET-ALL: } -> tensor<i32> // DET-ALL: } -> tensor<i32>
// DET-ALL: tensor.extract %{{.*}}[] : tensor<i32> // DET-ALL: tensor.extract %{{.*}}[] : tensor<i32>
// DET-ALL: cmpi slt, %{{.*}}, %{{.*}} : i32 // DET-ALL: cmpi slt, %{{.*}}, %{{.*}} : i32
// DET-ALL: cond_br %{{.*}}, ^[[bb2:.*]](%{{.*}} : i32), ^[[bb3:.*]](%{{.*}} : i32) // DET-ALL: cf.cond_br %{{.*}}, ^[[bb2:.*]](%{{.*}} : i32), ^[[bb3:.*]](%{{.*}} : i32)
// DET-ALL: ^[[bb2]](%{{.*}}: i32) // DET-ALL: ^[[bb2]](%{{.*}}: i32)
// DET-ALL: tensor.from_elements %{{.*}} : tensor<i32> // DET-ALL: tensor.from_elements %{{.*}} : tensor<i32>
// DET-ALL: linalg.init_tensor [10] : tensor<10xi32> // DET-ALL: linalg.init_tensor [10] : tensor<10xi32>
// DET-ALL: linalg.generic {{{.*}}} ins(%{{.*}} : tensor<i32>) outs(%{{.*}} : tensor<10xi32>) { // DET-ALL: linalg.generic {{{.*}}} ins(%{{.*}} : tensor<i32>) outs(%{{.*}} : tensor<10xi32>) {
// DET-ALL: ^bb0(%{{.*}}: i32, %{{.*}}: i32): // DET-ALL: ^bb0(%{{.*}}: i32, %{{.*}}: i32):
// DET-ALL: linalg.yield %{{.*}} : i32 // DET-ALL: linalg.yield %{{.*}} : i32
// DET-ALL: } -> tensor<10xi32> // DET-ALL: } -> tensor<10xi32>
// DET-ALL: br ^[[bb1]](%{{.*}} : tensor<10xi32>) // DET-ALL: cf.br ^[[bb1]](%{{.*}} : tensor<10xi32>)
// DET-ALL: ^[[bb3]](%{{.*}}: i32) // DET-ALL: ^[[bb3]](%{{.*}}: i32)
// DET-ALL: tensor.from_elements %{{.*}} : tensor<i32> // DET-ALL: tensor.from_elements %{{.*}} : tensor<i32>
// DET-ALL: return %{{.*}} : tensor<i32> // DET-ALL: return %{{.*}} : tensor<i32>
// DET-ALL: } // DET-ALL: }
// DET-CF-LABEL: func @main // DET-CF-LABEL: func @main
// DET-CF-SAME: (%{{.*}}: tensor<10xi32>, %{{.*}}: tensor<i32>) // DET-CF-SAME: (%{{.*}}: tensor<10xi32>, %{{.*}}: tensor<i32>)
// DET-CF: br ^[[bb1:.*]](%{{.*}} : tensor<10xi32>) // DET-CF: cf.br ^[[bb1:.*]](%{{.*}} : tensor<10xi32>)
// DET-CF: ^bb1(%{{.*}}: tensor<10xi32>) // DET-CF: ^bb1(%{{.*}}: tensor<10xi32>)
// DET-CF: %{{.*}} = linalg.generic {{{.*}}} ins(%{{.*}} : tensor<10xi32>) outs(%{{.*}} : tensor<i32>) { // DET-CF: %{{.*}} = linalg.generic {{{.*}}} ins(%{{.*}} : tensor<10xi32>) outs(%{{.*}} : tensor<i32>) {
// DET-CF: tensor.extract %{{.*}}[] : tensor<i32> // DET-CF: tensor.extract %{{.*}}[] : tensor<i32>
// DET-CF: cmpi slt, %{{.*}}, %{{.*}} : i32 // DET-CF: cmpi slt, %{{.*}}, %{{.*}} : i32
// DET-CF: cond_br %{{.*}}, ^bb2(%{{.*}} : tensor<i32>), ^bb3(%{{.*}} : tensor<i32>) // DET-CF: cf.cond_br %{{.*}}, ^bb2(%{{.*}} : tensor<i32>), ^bb3(%{{.*}} : tensor<i32>)
// DET-CF: ^bb2(%{{.*}}: tensor<i32>) // DET-CF: ^bb2(%{{.*}}: tensor<i32>)
// DET-CF: %{{.*}} = linalg.generic {{{.*}}} ins(%{{.*}} : tensor<i32>) outs(%{{.*}} : tensor<10xi32>) { // DET-CF: %{{.*}} = linalg.generic {{{.*}}} ins(%{{.*}} : tensor<i32>) outs(%{{.*}} : tensor<10xi32>) {
// DET-CF: br ^bb1(%{{.*}} : tensor<10xi32>) // DET-CF: cf.br ^bb1(%{{.*}} : tensor<10xi32>)
// DET-CF: ^bb3(%{{.*}}: tensor<i32>) // DET-CF: ^bb3(%{{.*}}: tensor<i32>)
// DET-CF: return %{{.*}} : tensor<i32> // DET-CF: return %{{.*}} : tensor<i32>
// DET-CF: } // DET-CF: }

mlir/test/Dialect/Linalg/detensorize_while_pure_cf.mlir

// RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline="builtin.func(linalg-detensorize)" | FileCheck %s // RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline="builtin.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 = []
} }
func @main() -> () attributes {} { func @main() -> () attributes {} {
%c0 = arith.constant 0 : i32 %c0 = arith.constant 0 : i32
%0 = tensor.from_elements %c0 : tensor<1xi32> %0 = tensor.from_elements %c0 : tensor<1xi32>
%reshaped0 = tensor.collapse_shape %0 [] : tensor<1xi32> into tensor<i32> %reshaped0 = tensor.collapse_shape %0 [] : tensor<1xi32> into tensor<i32>
%c10 = arith.constant 10 : i32 %c10 = arith.constant 10 : i32
%1 = tensor.from_elements %c10 : tensor<1xi32> %1 = tensor.from_elements %c10 : tensor<1xi32>
%reshaped1 = tensor.collapse_shape %1 [] : tensor<1xi32> into tensor<i32> %reshaped1 = tensor.collapse_shape %1 [] : tensor<1xi32> into tensor<i32>
br ^bb1(%reshaped0 : tensor<i32>) cf.br ^bb1(%reshaped0 : tensor<i32>)
^bb1(%2: tensor<i32>): // 2 preds: ^bb0, ^bb2 ^bb1(%2: tensor<i32>): // 2 preds: ^bb0, ^bb2
%3 = linalg.init_tensor [] : tensor<i1> %3 = linalg.init_tensor [] : tensor<i1>
%4 = linalg.generic #attrs %4 = linalg.generic #attrs
ins(%2, %reshaped1 : tensor<i32>, tensor<i32>) ins(%2, %reshaped1 : tensor<i32>, tensor<i32>)
outs(%3 : tensor<i1>) { outs(%3 : tensor<i1>) {
^bb0(%arg0: i32, %arg1: i32, %arg2: i1): ^bb0(%arg0: i32, %arg1: i32, %arg2: i1):
%8 = arith.cmpi slt, %arg0, %arg1 : i32 %8 = arith.cmpi slt, %arg0, %arg1 : i32
linalg.yield %8 : i1 linalg.yield %8 : i1
} -> tensor<i1> } -> tensor<i1>
%5 = tensor.extract %4[] : tensor<i1> %5 = tensor.extract %4[] : tensor<i1>
cond_br %5, ^bb2(%2 : tensor<i32>), ^bb3 cf.cond_br %5, ^bb2(%2 : tensor<i32>), ^bb3
^bb2(%6: tensor<i32>): // pred: ^bb1 ^bb2(%6: tensor<i32>): // pred: ^bb1
%7 = linalg.init_tensor [] : tensor<i32> %7 = linalg.init_tensor [] : tensor<i32>
%8 = linalg.generic #attrs %8 = linalg.generic #attrs
ins(%6, %6 : tensor<i32>, tensor<i32>) ins(%6, %6 : tensor<i32>, tensor<i32>)
outs(%7 : tensor<i32>) { outs(%7 : tensor<i32>) {
^bb0(%arg0: i32, %arg1: i32, %arg2: i32): ^bb0(%arg0: i32, %arg1: i32, %arg2: i32):
%9 = arith.addi %arg0, %arg1 : i32 %9 = arith.addi %arg0, %arg1 : i32
linalg.yield %9 : i32 linalg.yield %9 : i32
} -> tensor<i32> } -> tensor<i32>
br ^bb1(%8 : tensor<i32>) cf.br ^bb1(%8 : tensor<i32>)
^bb3: // pred: ^bb1 ^bb3: // pred: ^bb1
return return
} }
// CHECK-LABEL: func @main // CHECK-LABEL: func @main
// CHECK-NEXT: arith.constant 0 : i32 // CHECK-NEXT: arith.constant 0 : i32
// CHECK-NEXT: arith.constant 10 // CHECK-NEXT: arith.constant 10
// CHECK-NEXT: br ^[[bb1:.*]](%{{.*}} : i32) // CHECK-NEXT: cf.br ^[[bb1:.*]](%{{.*}} : i32)
// CHECK-NEXT: ^[[bb1]](%{{.*}}: i32) // CHECK-NEXT: ^[[bb1]](%{{.*}}: i32)
// CHECK-NEXT: %{{.*}} = arith.cmpi slt, %{{.*}}, %{{.*}} // CHECK-NEXT: %{{.*}} = arith.cmpi slt, %{{.*}}, %{{.*}}
// CHECK-NEXT: cond_br %{{.*}}, ^[[bb2:.*]](%{{.*}} : i32), ^[[bb3:.*]] // CHECK-NEXT: cf.cond_br %{{.*}}, ^[[bb2:.*]](%{{.*}} : i32), ^[[bb3:.*]]
// CHECK-NEXT: ^[[bb2]](%{{.*}}: i32) // CHECK-NEXT: ^[[bb2]](%{{.*}}: i32)
// CHECK-NEXT: %{{.*}} = arith.addi %{{.*}}, %{{.*}} // CHECK-NEXT: %{{.*}} = arith.addi %{{.*}}, %{{.*}}
// CHECK-NEXT: br ^[[bb1]](%{{.*}} : i32) // CHECK-NEXT: cf.br ^[[bb1]](%{{.*}} : i32)
// CHECK-NEXT: ^[[bb3]]: // CHECK-NEXT: ^[[bb3]]:
// CHECK-NEXT: return // CHECK-NEXT: return
// CHECK-NEXT: } // CHECK-NEXT: }

mlir/test/Dialect/OpenMP/ops.mlir

Show First 20 Lines • Show All 244 Lines • ▼ Show 20 Lines
} }
// CHECK-LABEL: omp_wsloop_pretty_multi_block // CHECK-LABEL: omp_wsloop_pretty_multi_block
func @omp_wsloop_pretty_multi_block(%lb : index, %ub : index, %step : index, %data1 : memref<?xi32>, %data2 : memref<?xi32>) -> () { func @omp_wsloop_pretty_multi_block(%lb : index, %ub : index, %step : index, %data1 : memref<?xi32>, %data2 : memref<?xi32>) -> () {
// CHECK: omp.wsloop (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}}) // CHECK: omp.wsloop (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) { omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) {
%1 = "test.payload"(%iv) : (index) -> (i32) %1 = "test.payload"(%iv) : (index) -> (i32)
br ^bb1(%1: i32) cf.br ^bb1(%1: i32)
^bb1(%arg: i32): ^bb1(%arg: i32):
memref.store %arg, %data1[%iv] : memref<?xi32> memref.store %arg, %data1[%iv] : memref<?xi32>
omp.yield omp.yield
} }
// CHECK: omp.wsloop (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}}) // CHECK: omp.wsloop (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) { omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) {
%c = "test.condition"(%iv) : (index) -> (i1) %c = "test.condition"(%iv) : (index) -> (i1)
%v1 = "test.payload"(%iv) : (index) -> (i32) %v1 = "test.payload"(%iv) : (index) -> (i32)
cond_br %c, ^bb1(%v1: i32), ^bb2(%v1: i32) cf.cond_br %c, ^bb1(%v1: i32), ^bb2(%v1: i32)
^bb1(%arg0: i32): ^bb1(%arg0: i32):
memref.store %arg0, %data1[%iv] : memref<?xi32> memref.store %arg0, %data1[%iv] : memref<?xi32>
br ^bb3 cf.br ^bb3
^bb2(%arg1: i32): ^bb2(%arg1: i32):
memref.store %arg1, %data2[%iv] : memref<?xi32> memref.store %arg1, %data2[%iv] : memref<?xi32>
br ^bb3 cf.br ^bb3
^bb3: ^bb3:
omp.yield omp.yield
} }
// CHECK: omp.wsloop (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}}) // CHECK: omp.wsloop (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) { omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) {
%c = "test.condition"(%iv) : (index) -> (i1) %c = "test.condition"(%iv) : (index) -> (i1)
%v1 = "test.payload"(%iv) : (index) -> (i32) %v1 = "test.payload"(%iv) : (index) -> (i32)
cond_br %c, ^bb1(%v1: i32), ^bb2(%v1: i32) cf.cond_br %c, ^bb1(%v1: i32), ^bb2(%v1: i32)
^bb1(%arg0: i32): ^bb1(%arg0: i32):
memref.store %arg0, %data1[%iv] : memref<?xi32> memref.store %arg0, %data1[%iv] : memref<?xi32>
omp.yield omp.yield
^bb2(%arg1: i32): ^bb2(%arg1: i32):
memref.store %arg1, %data2[%iv] : memref<?xi32> memref.store %arg1, %data2[%iv] : memref<?xi32>
omp.yield omp.yield
} }
return return
} }
// CHECK-LABEL: omp_wsloop_pretty_non_index // CHECK-LABEL: omp_wsloop_pretty_non_index
func @omp_wsloop_pretty_non_index(%lb1 : i32, %ub1 : i32, %step1 : i32, %lb2 : i64, %ub2 : i64, %step2 : i64, func @omp_wsloop_pretty_non_index(%lb1 : i32, %ub1 : i32, %step1 : i32, %lb2 : i64, %ub2 : i64, %step2 : i64,
%data1 : memref<?xi32>, %data2 : memref<?xi64>) -> () { %data1 : memref<?xi32>, %data2 : memref<?xi64>) -> () {
// CHECK: omp.wsloop (%{{.*}}) : i32 = (%{{.*}}) to (%{{.*}}) step (%{{.*}}) // CHECK: omp.wsloop (%{{.*}}) : i32 = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
omp.wsloop (%iv1) : i32 = (%lb1) to (%ub1) step (%step1) { omp.wsloop (%iv1) : i32 = (%lb1) to (%ub1) step (%step1) {
%1 = "test.payload"(%iv1) : (i32) -> (index) %1 = "test.payload"(%iv1) : (i32) -> (index)
br ^bb1(%1: index) cf.br ^bb1(%1: index)
^bb1(%arg1: index): ^bb1(%arg1: index):
memref.store %iv1, %data1[%arg1] : memref<?xi32> memref.store %iv1, %data1[%arg1] : memref<?xi32>
omp.yield omp.yield
} }
// CHECK: omp.wsloop (%{{.*}}) : i64 = (%{{.*}}) to (%{{.*}}) step (%{{.*}}) // CHECK: omp.wsloop (%{{.*}}) : i64 = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
omp.wsloop (%iv2) : i64 = (%lb2) to (%ub2) step (%step2) { omp.wsloop (%iv2) : i64 = (%lb2) to (%ub2) step (%step2) {
%2 = "test.payload"(%iv2) : (i64) -> (index) %2 = "test.payload"(%iv2) : (i64) -> (index)
br ^bb1(%2: index) cf.br ^bb1(%2: index)
^bb1(%arg2: index): ^bb1(%arg2: index):
memref.store %iv2, %data2[%arg2] : memref<?xi64> memref.store %iv2, %data2[%arg2] : memref<?xi64>
omp.yield omp.yield
} }
return return
} }
▲ Show 20 Lines • Show All 443 Lines • Show Last 20 Lines

mlir/test/Dialect/SCF/canonicalize.mlir

Show First 20 Lines • Show All 1,121 Lines • ▼ Show 20 Lines
// ----- // -----
// CHECK-LABEL: func @propagate_into_execute_region // CHECK-LABEL: func @propagate_into_execute_region
func @propagate_into_execute_region() { func @propagate_into_execute_region() {
%cond = arith.constant 0 : i1 %cond = arith.constant 0 : i1
affine.for %i = 0 to 100 { affine.for %i = 0 to 100 {
"test.foo"() : () -> () "test.foo"() : () -> ()
%v = scf.execute_region -> i64 { %v = scf.execute_region -> i64 {
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
%c1 = arith.constant 1 : i64 %c1 = arith.constant 1 : i64
br ^bb3(%c1 : i64) cf.br ^bb3(%c1 : i64)
^bb2: ^bb2:
%c2 = arith.constant 2 : i64 %c2 = arith.constant 2 : i64
br ^bb3(%c2 : i64) cf.br ^bb3(%c2 : i64)
^bb3(%x : i64): ^bb3(%x : i64):
scf.yield %x : i64 scf.yield %x : i64
} }
"test.bar"(%v) : (i64) -> () "test.bar"(%v) : (i64) -> ()
// CHECK: %[[C2:.*]] = arith.constant 2 : i64 // CHECK: %[[C2:.*]] = arith.constant 2 : i64
// CHECK: "test.foo" // CHECK: "test.foo"
// CHECK-NEXT: "test.bar"(%[[C2]]) : (i64) -> () // CHECK-NEXT: "test.bar"(%[[C2]]) : (i64) -> ()
Show All 25 Lines
// ----- // -----
// CHECK-LABEL: func @func_execute_region_elim // CHECK-LABEL: func @func_execute_region_elim
func @func_execute_region_elim() { func @func_execute_region_elim() {
"test.foo"() : () -> () "test.foo"() : () -> ()
%v = scf.execute_region -> i64 { %v = scf.execute_region -> i64 {
%c = "test.cmp"() : () -> i1 %c = "test.cmp"() : () -> i1
cond_br %c, ^bb2, ^bb3 cf.cond_br %c, ^bb2, ^bb3
^bb2: ^bb2:
%x = "test.val1"() : () -> i64 %x = "test.val1"() : () -> i64
br ^bb4(%x : i64) cf.br ^bb4(%x : i64)
^bb3: ^bb3:
%y = "test.val2"() : () -> i64 %y = "test.val2"() : () -> i64
br ^bb4(%y : i64) cf.br ^bb4(%y : i64)
^bb4(%z : i64): ^bb4(%z : i64):
scf.yield %z : i64 scf.yield %z : i64
} }
"test.bar"(%v) : (i64) -> () "test.bar"(%v) : (i64) -> ()
return return
} }
// CHECK-NOT: execute_region // CHECK-NOT: execute_region
// CHECK: "test.foo" // CHECK: "test.foo"
// CHECK: %[[cmp:.+]] = "test.cmp" // CHECK: %[[cmp:.+]] = "test.cmp"
// CHECK: cond_br %[[cmp]], ^[[bb1:.+]], ^[[bb2:.+]] // CHECK: cf.cond_br %[[cmp]], ^[[bb1:.+]], ^[[bb2:.+]]
// CHECK: ^[[bb1]]: // CHECK: ^[[bb1]]:
// CHECK: %[[x:.+]] = "test.val1" // CHECK: %[[x:.+]] = "test.val1"
// CHECK: br ^[[bb3:.+]](%[[x]] : i64) // CHECK: cf.br ^[[bb3:.+]](%[[x]] : i64)
// CHECK: ^[[bb2]]: // CHECK: ^[[bb2]]:
// CHECK: %[[y:.+]] = "test.val2" // CHECK: %[[y:.+]] = "test.val2"
// CHECK: br ^[[bb3]](%[[y:.+]] : i64) // CHECK: cf.br ^[[bb3]](%[[y:.+]] : i64)
// CHECK: ^[[bb3]](%[[z:.+]]: i64): // CHECK: ^[[bb3]](%[[z:.+]]: i64):
// CHECK: "test.bar"(%[[z]]) // CHECK: "test.bar"(%[[z]])
// CHECK: return // CHECK: return
// ----- // -----
// CHECK-LABEL: func @func_execute_region_elim_multi_yield // CHECK-LABEL: func @func_execute_region_elim_multi_yield
func @func_execute_region_elim_multi_yield() { func @func_execute_region_elim_multi_yield() {
"test.foo"() : () -> () "test.foo"() : () -> ()
%v = scf.execute_region -> i64 { %v = scf.execute_region -> i64 {
%c = "test.cmp"() : () -> i1 %c = "test.cmp"() : () -> i1
cond_br %c, ^bb2, ^bb3 cf.cond_br %c, ^bb2, ^bb3
^bb2: ^bb2:
%x = "test.val1"() : () -> i64 %x = "test.val1"() : () -> i64
scf.yield %x : i64 scf.yield %x : i64
^bb3: ^bb3:
%y = "test.val2"() : () -> i64 %y = "test.val2"() : () -> i64
scf.yield %y : i64 scf.yield %y : i64
} }
"test.bar"(%v) : (i64) -> () "test.bar"(%v) : (i64) -> ()
return return
} }
// CHECK-NOT: execute_region // CHECK-NOT: execute_region
// CHECK: "test.foo" // CHECK: "test.foo"
// CHECK: %[[cmp:.+]] = "test.cmp" // CHECK: %[[cmp:.+]] = "test.cmp"
// CHECK: cond_br %[[cmp]], ^[[bb1:.+]], ^[[bb2:.+]] // CHECK: cf.cond_br %[[cmp]], ^[[bb1:.+]], ^[[bb2:.+]]
// CHECK: ^[[bb1]]: // CHECK: ^[[bb1]]:
// CHECK: %[[x:.+]] = "test.val1" // CHECK: %[[x:.+]] = "test.val1"
// CHECK: br ^[[bb3:.+]](%[[x]] : i64) // CHECK: cf.br ^[[bb3:.+]](%[[x]] : i64)
// CHECK: ^[[bb2]]: // CHECK: ^[[bb2]]:
// CHECK: %[[y:.+]] = "test.val2" // CHECK: %[[y:.+]] = "test.val2"
// CHECK: br ^[[bb3]](%[[y:.+]] : i64) // CHECK: cf.br ^[[bb3]](%[[y:.+]] : i64)
// CHECK: ^[[bb3]](%[[z:.+]]: i64): // CHECK: ^[[bb3]](%[[z:.+]]: i64):
// CHECK: "test.bar"(%[[z]]) // CHECK: "test.bar"(%[[z]])
// CHECK: return // CHECK: return

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

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Lines
// CHECK: %[[VAL_5:.*]]:2 = scf.while (%[[VAL_6:.*]] = %[[VAL_3]], %[[VAL_7:.*]] = %[[VAL_0]]) : (index, i32) -> (index, i32) { // CHECK: %[[VAL_5:.*]]:2 = scf.while (%[[VAL_6:.*]] = %[[VAL_3]], %[[VAL_7:.*]] = %[[VAL_0]]) : (index, i32) -> (index, i32) {
// CHECK: %[[VAL_8:.*]] = arith.cmpi slt, %[[VAL_6]], %[[VAL_1]] : index // CHECK: %[[VAL_8:.*]] = arith.cmpi slt, %[[VAL_6]], %[[VAL_1]] : index
// CHECK: scf.condition(%[[VAL_8]]) %[[VAL_6]], %[[VAL_7]] : index, i32 // CHECK: scf.condition(%[[VAL_8]]) %[[VAL_6]], %[[VAL_7]] : index, i32
// CHECK: } do { // CHECK: } do {
// CHECK: ^bb0(%[[VAL_9:.*]]: index, %[[VAL_10:.*]]: i32): // CHECK: ^bb0(%[[VAL_9:.*]]: index, %[[VAL_10:.*]]: i32):
// CHECK: %[[VAL_11:.*]] = arith.addi %[[VAL_9]], %[[VAL_4]] : index // CHECK: %[[VAL_11:.*]] = arith.addi %[[VAL_9]], %[[VAL_4]] : index
// CHECK: %[[VAL_12:.*]] = scf.execute_region -> i32 { // CHECK: %[[VAL_12:.*]] = scf.execute_region -> i32 {
// CHECK: %[[VAL_13:.*]] = arith.cmpi slt, %[[VAL_9]], %[[VAL_4]] : index // CHECK: %[[VAL_13:.*]] = arith.cmpi slt, %[[VAL_9]], %[[VAL_4]] : index
// CHECK: cond_br %[[VAL_13]], ^bb1, ^bb2 // CHECK: cf.cond_br %[[VAL_13]], ^bb1, ^bb2
// CHECK: ^bb1: // CHECK: ^bb1:
// CHECK: %[[VAL_14:.*]] = arith.subi %[[VAL_10]], %[[VAL_0]] : i32 // CHECK: %[[VAL_14:.*]] = arith.subi %[[VAL_10]], %[[VAL_0]] : i32
// CHECK: scf.yield %[[VAL_14]] : i32 // CHECK: scf.yield %[[VAL_14]] : i32
// CHECK: ^bb2: // CHECK: ^bb2:
// CHECK: %[[VAL_15:.*]] = arith.muli %[[VAL_10]], %[[VAL_2]] : i32 // CHECK: %[[VAL_15:.*]] = arith.muli %[[VAL_10]], %[[VAL_2]] : i32
// CHECK: scf.yield %[[VAL_15]] : i32 // CHECK: scf.yield %[[VAL_15]] : i32
// CHECK: } // CHECK: }
// CHECK: scf.yield %[[VAL_11]], %[[VAL_16:.*]] : index, i32 // CHECK: scf.yield %[[VAL_11]], %[[VAL_16:.*]] : index, i32
// CHECK: } // CHECK: }
// CHECK: return %[[VAL_17:.*]]#1 : i32 // CHECK: return %[[VAL_17:.*]]#1 : i32
// CHECK: } // CHECK: }
func @exec_region_multiple_yields(%arg0: i32, %arg1: index, %arg2: i32) -> i32 { func @exec_region_multiple_yields(%arg0: i32, %arg1: index, %arg2: i32) -> i32 {
%c1_i32 = arith.constant 1 : i32 %c1_i32 = arith.constant 1 : i32
%c2_i32 = arith.constant 2 : i32 %c2_i32 = arith.constant 2 : i32
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c5 = arith.constant 5 : index %c5 = arith.constant 5 : index
%0 = scf.for %i = %c0 to %arg1 step %c1 iter_args(%iarg0 = %arg0) -> i32 { %0 = scf.for %i = %c0 to %arg1 step %c1 iter_args(%iarg0 = %arg0) -> i32 {
%2 = scf.execute_region -> i32 { %2 = scf.execute_region -> i32 {
%1 = arith.cmpi slt, %i, %c1 : index %1 = arith.cmpi slt, %i, %c1 : index
cond_br %1, ^bb1, ^bb2 cf.cond_br %1, ^bb1, ^bb2
^bb1: ^bb1:
%2 = arith.subi %iarg0, %arg0 : i32 %2 = arith.subi %iarg0, %arg0 : i32
scf.yield %2 : i32 scf.yield %2 : i32
^bb2: ^bb2:
%3 = arith.muli %iarg0, %arg2 : i32 %3 = arith.muli %iarg0, %arg2 : i32
scf.yield %3 : i32 scf.yield %3 : i32
} }
scf.yield %2 : i32 scf.yield %2 : i32
} }
return %0 : i32 return %0 : i32
} }

mlir/test/Dialect/SCF/ops.mlir

Show First 20 Lines • Show All 292 Lines • ▼ Show 20 Linesfunc @execute_region() -> i64 {
// CHECK: scf.execute_region -> (i64, i64) { // CHECK: scf.execute_region -> (i64, i64) {
%res2:2 = scf.execute_region -> (i64, i64) { %res2:2 = scf.execute_region -> (i64, i64) {
%c1 = arith.constant 1 : i64 %c1 = arith.constant 1 : i64
scf.yield %c1, %c1 : i64, i64 scf.yield %c1, %c1 : i64, i64
} }
// CHECK: scf.execute_region { // CHECK: scf.execute_region {
// CHECK-NEXT: br ^bb1 // CHECK-NEXT: cf.br ^bb1
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
// CHECK-NEXT: scf.yield // CHECK-NEXT: scf.yield
// CHECK-NEXT: } // CHECK-NEXT: }
"scf.execute_region"() ({ "scf.execute_region"() ({
^bb0: ^bb0:
br ^bb1 cf.br ^bb1
^bb1: ^bb1:
scf.yield scf.yield
}) : () -> () }) : () -> ()
return %res : i64 return %res : i64
} }

mlir/test/Dialect/Standard/canonicalize-cf.mlir

  • This file was moved to mlir/test/Dialect/ControlFlow/canonicalize.mlir.

mlir/test/Dialect/Standard/canonicalize.mlir

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Linesfunc @select_extui_i1(%arg0: i1) -> i1 {
%c0_i1 = arith.constant false %c0_i1 = arith.constant false
%c1_i1 = arith.constant true %c1_i1 = arith.constant true
%res = arith.select %arg0, %c1_i1, %c0_i1 : i1 %res = arith.select %arg0, %c1_i1, %c0_i1 : i1
return %res : i1 return %res : i1
} }
// ----- // -----
// CHECK-LABEL: @branchCondProp
// CHECK: %[[trueval:.+]] = arith.constant true
// CHECK: %[[falseval:.+]] = arith.constant false
// CHECK: "test.consumer1"(%[[trueval]]) : (i1) -> ()
// CHECK: "test.consumer2"(%[[falseval]]) : (i1) -> ()
func @branchCondProp(%arg0: i1) {
cond_br %arg0, ^trueB, ^falseB
^trueB:
"test.consumer1"(%arg0) : (i1) -> ()
br ^exit
^falseB:
"test.consumer2"(%arg0) : (i1) -> ()
br ^exit
^exit:
return
}
// -----
// CHECK-LABEL: @selToNot // CHECK-LABEL: @selToNot
// CHECK: %[[trueval:.+]] = arith.constant true // CHECK: %[[trueval:.+]] = arith.constant true
// CHECK: %[[res:.+]] = arith.xori %arg0, %[[trueval]] : i1 // CHECK: %[[res:.+]] = arith.xori %arg0, %[[trueval]] : i1
// CHECK: return %[[res]] // CHECK: return %[[res]]
func @selToNot(%arg0: i1) -> i1 { func @selToNot(%arg0: i1) -> i1 {
%true = arith.constant true %true = arith.constant true
%false = arith.constant false %false = arith.constant false
%res = arith.select %arg0, %false, %true : i1 %res = arith.select %arg0, %false, %true : i1
Show All 14 Lines

mlir/test/Dialect/Standard/func-bufferize.mlir

// RUN: mlir-opt %s -func-bufferize -split-input-file -verify-diagnostics | FileCheck %s // RUN: mlir-opt %s -func-bufferize -split-input-file -verify-diagnostics | FileCheck %s
// CHECK-LABEL: func @identity( // CHECK-LABEL: func @identity(
// CHECK-SAME: %[[ARG:.*]]: memref<f32>) -> memref<f32> { // CHECK-SAME: %[[ARG:.*]]: memref<f32>) -> memref<f32> {
// CHECK: return %[[ARG]] : memref<f32> // CHECK: return %[[ARG]] : memref<f32>
func @identity(%arg0: tensor<f32>) -> tensor<f32> { func @identity(%arg0: tensor<f32>) -> tensor<f32> {
return %arg0 : tensor<f32> return %arg0 : tensor<f32>
} }
// CHECK-LABEL: func @block_arguments( // CHECK-LABEL: func @block_arguments(
// CHECK-SAME: %[[ARG:.*]]: memref<f32>) -> memref<f32> { // CHECK-SAME: %[[ARG:.*]]: memref<f32>) -> memref<f32> {
// CHECK: br ^bb1(%[[ARG]] : memref<f32>) // CHECK: cf.br ^bb1(%[[ARG]] : memref<f32>)
// CHECK: ^bb1(%[[BBARG:.*]]: memref<f32>): // CHECK: ^bb1(%[[BBARG:.*]]: memref<f32>):
// CHECK: return %[[BBARG]] : memref<f32> // CHECK: return %[[BBARG]] : memref<f32>
func @block_arguments(%arg0: tensor<f32>) -> tensor<f32> { func @block_arguments(%arg0: tensor<f32>) -> tensor<f32> {
br ^bb1(%arg0: tensor<f32>) cf.br ^bb1(%arg0: tensor<f32>)
^bb1(%bbarg: tensor<f32>): ^bb1(%bbarg: tensor<f32>):
return %bbarg : tensor<f32> return %bbarg : tensor<f32>
} }
// CHECK-LABEL: func private @source() -> memref<f32> // CHECK-LABEL: func private @source() -> memref<f32>
// CHECK-LABEL: func @call_source() -> memref<f32> { // CHECK-LABEL: func @call_source() -> memref<f32> {
// CHECK: %[[RET:.*]] = call @source() : () -> memref<f32> // CHECK: %[[RET:.*]] = call @source() : () -> memref<f32>
// CHECK: return %[[RET]] : memref<f32> // CHECK: return %[[RET]] : memref<f32>
Show All 22 Lines
} }
// ----- // -----
// Because this pass updates block arguments, it needs to also atomically // Because this pass updates block arguments, it needs to also atomically
// update all terminators and issue an error if that is not possible. // update all terminators and issue an error if that is not possible.
func @unable_to_update_terminator(%arg0: tensor<f32>) -> tensor<f32> { func @unable_to_update_terminator(%arg0: tensor<f32>) -> tensor<f32> {
%0 = arith.constant true %0 = arith.constant true
cond_br %0, ^bb1(%arg0: tensor<f32>), ^bb2(%arg0: tensor<f32>) cf.cond_br %0, ^bb1(%arg0: tensor<f32>), ^bb2(%arg0: tensor<f32>)
^bb1(%bbarg0: tensor<f32>): ^bb1(%bbarg0: tensor<f32>):
// expected-error @+1 {{failed to legalize operation 'test.terminator'}} // expected-error @+1 {{failed to legalize operation 'test.terminator'}}
"test.terminator"() : () -> () "test.terminator"() : () -> ()
^bb2(%bbarg1: tensor<f32>): ^bb2(%bbarg1: tensor<f32>):
return %bbarg1 : tensor<f32> return %bbarg1 : tensor<f32>
} }
// ----- // -----
Show All 20 Lines

mlir/test/Dialect/Standard/ops.mlir

  • This file was moved to mlir/test/Dialect/ControlFlow/ops.mlir.

mlir/test/Dialect/Standard/parser.mlir

  • This file was moved to mlir/test/Dialect/ControlFlow/invalid.mlir.

mlir/test/IR/invalid.mlir

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Lines
func @tensor_encoding_mismatch(%arg0: tensor<8xi32, "enc">) -> (tensor<8xi32>) { // expected-note {{prior use here}} func @tensor_encoding_mismatch(%arg0: tensor<8xi32, "enc">) -> (tensor<8xi32>) { // expected-note {{prior use here}}
return %arg0: tensor<8xi32> // expected-error {{use of value '%arg0' expects different type than prior uses: 'tensor<8xi32>' vs 'tensor<8xi32, "enc">'}} return %arg0: tensor<8xi32> // expected-error {{use of value '%arg0' expects different type than prior uses: 'tensor<8xi32>' vs 'tensor<8xi32, "enc">'}}
} }
// ----- // -----
func @bad_branch() { func @bad_branch() {
^bb12: ^bb12:
br ^missing // expected-error {{reference to an undefined block}} cf.br ^missing // expected-error {{reference to an undefined block}}
} }
// ----- // -----
func @block_redef() { func @block_redef() {
^bb42: ^bb42:
return return
^bb42: // expected-error {{redefinition of block '^bb42'}} ^bb42: // expected-error {{redefinition of block '^bb42'}}
Show All 30 Lines
^bb42 (%0): // expected-error {{expected ':' and type for SSA operand}} ^bb42 (%0): // expected-error {{expected ':' and type for SSA operand}}
return return
} }
// ----- // -----
func @block_arg_no_close_paren() { func @block_arg_no_close_paren() {
^bb42: ^bb42:
br ^bb2( // expected-error@+1 {{expected ':'}} cf.br ^bb2( // expected-error@+1 {{expected ':'}}
return return
} }
// ----- // -----
func @block_first_has_predecessor() { func @block_first_has_predecessor() {
// expected-error@-1 {{entry block of region may not have predecessors}} // expected-error@-1 {{entry block of region may not have predecessors}}
^bb42: ^bb42:
br ^bb43 cf.br ^bb43
^bb43: ^bb43:
br ^bb42 cf.br ^bb42
} }
// ----- // -----
func @no_return() { func @no_return() {
%x = arith.constant 0 : i32 %x = arith.constant 0 : i32
%y = arith.constant 1 : i32 // expected-error {{block with no terminator}} %y = arith.constant 1 : i32 // expected-error {{block with no terminator}}
} }
// ----- // -----
func @no_terminator() { func @no_terminator() {
br ^bb1 cf.br ^bb1
^bb1: ^bb1:
%x = arith.constant 0 : i32 %x = arith.constant 0 : i32
%y = arith.constant 1 : i32 // expected-error {{block with no terminator}} %y = arith.constant 1 : i32 // expected-error {{block with no terminator}}
} }
// ----- // -----
▲ Show 20 Lines • Show All 169 Lines • ▼ Show 20 Lines
func @func_resulterror() -> i32 { func @func_resulterror() -> i32 {
return // expected-error {{'std.return' op has 0 operands, but enclosing function (@func_resulterror) returns 1}} return // expected-error {{'std.return' op has 0 operands, but enclosing function (@func_resulterror) returns 1}}
} }
// ----- // -----
func @argError() { func @argError() {
^bb1(%a: i64): // expected-note {{previously defined here}} ^bb1(%a: i64): // expected-note {{previously defined here}}
br ^bb2 cf.br ^bb2
^bb2(%a: i64): // expected-error{{redefinition of SSA value '%a'}} ^bb2(%a: i64): // expected-error{{redefinition of SSA value '%a'}}
return return
} }
// ----- // -----
func @br_mismatch() { func @br_mismatch() {
^bb0: ^bb0:
%0:2 = "foo"() : () -> (i1, i17) %0:2 = "foo"() : () -> (i1, i17)
// expected-error @+1 {{branch has 2 operands for successor #0, but target block has 1}} // expected-error @+1 {{branch has 2 operands for successor #0, but target block has 1}}
br ^bb1(%0#1, %0#0 : i17, i1) cf.br ^bb1(%0#1, %0#0 : i17, i1)
^bb1(%x: i17): ^bb1(%x: i17):
return return
} }
// ----- // -----
func @succ_arg_type_mismatch() { func @succ_arg_type_mismatch() {
^bb0: ^bb0:
%0 = "getBool"() : () -> i1 %0 = "getBool"() : () -> i1
// expected-error @+1 {{type mismatch for bb argument #0 of successor #0}} // expected-error @+1 {{type mismatch for bb argument #0 of successor #0}}
br ^bb1(%0 : i1) cf.br ^bb1(%0 : i1)
^bb1(%x: i32): ^bb1(%x: i32):
return return
} }
// ----- // -----
// Test no nested vector. // Test no nested vector.
func @vectors(vector<1 x vector<1xi32>>, vector<2x4xf32>) func @vectors(vector<1 x vector<1xi32>>, vector<2x4xf32>)
// expected-error@-1 {{vector elements must be int/index/float type}} // expected-error@-1 {{vector elements must be int/index/float type}}
// ----- // -----
func @condbr_notbool() { func @condbr_notbool() {
^bb0: ^bb0:
%a = "foo"() : () -> i32 // expected-note {{prior use here}} %a = "foo"() : () -> i32 // expected-note {{prior use here}}
cond_br %a, ^bb0, ^bb0 // expected-error {{use of value '%a' expects different type than prior uses: 'i1' vs 'i32'}} cf.cond_br %a, ^bb0, ^bb0 // expected-error {{use of value '%a' expects different type than prior uses: 'i1' vs 'i32'}}
} }
// ----- // -----
func @condbr_badtype() { func @condbr_badtype() {
^bb0: ^bb0:
%c = "foo"() : () -> i1 %c = "foo"() : () -> i1
%a = "foo"() : () -> i32 %a = "foo"() : () -> i32
cond_br %c, ^bb0(%a, %a : i32, ^bb0) // expected-error {{expected non-function type}} cf.cond_br %c, ^bb0(%a, %a : i32, ^bb0) // expected-error {{expected non-function type}}
} }
// ----- // -----
func @condbr_a_bb_is_not_a_type() { func @condbr_a_bb_is_not_a_type() {
^bb0: ^bb0:
%c = "foo"() : () -> i1 %c = "foo"() : () -> i1
%a = "foo"() : () -> i32 %a = "foo"() : () -> i32
cond_br %c, ^bb0(%a, %a : i32, i32), i32 // expected-error {{expected block name}} cf.cond_br %c, ^bb0(%a, %a : i32, i32), i32 // expected-error {{expected block name}}
} }
// ----- // -----
func @successors_in_non_terminator(%a : i32, %b : i32) { func @successors_in_non_terminator(%a : i32, %b : i32) {
%c = "arith.addi"(%a, %b)[^bb1] : () -> () // expected-error {{successors in non-terminator}} %c = "arith.addi"(%a, %b)[^bb1] : () -> () // expected-error {{successors in non-terminator}}
^bb1: ^bb1:
return return
Show All 33 Linesfunc @name_scope_failure() {
return return
} }
// ----- // -----
func @dominance_failure() { func @dominance_failure() {
^bb0: ^bb0:
"foo"(%x) : (i32) -> () // expected-error {{operand #0 does not dominate this use}} "foo"(%x) : (i32) -> () // expected-error {{operand #0 does not dominate this use}}
br ^bb1 cf.br ^bb1
^bb1: ^bb1:
%x = "bar"() : () -> i32 // expected-note {{operand defined here (op in the same region)}} %x = "bar"() : () -> i32 // expected-note {{operand defined here (op in the same region)}}
return return
} }
// ----- // -----
func @dominance_failure() { func @dominance_failure() {
^bb0: ^bb0:
"foo"(%x) : (i32) -> () // expected-error {{operand #0 does not dominate this use}} "foo"(%x) : (i32) -> () // expected-error {{operand #0 does not dominate this use}}
%x = "bar"() : () -> i32 // expected-note {{operand defined here (op in the same block)}} %x = "bar"() : () -> i32 // expected-note {{operand defined here (op in the same block)}}
br ^bb1 cf.br ^bb1
^bb1: ^bb1:
return return
} }
// ----- // -----
func @dominance_failure() { func @dominance_failure() {
"foo"() ({ "foo"() ({
"foo"(%x) : (i32) -> () // expected-error {{operand #0 does not dominate this use}} "foo"(%x) : (i32) -> () // expected-error {{operand #0 does not dominate this use}}
}) : () -> () }) : () -> ()
%x = "bar"() : () -> i32 // expected-note {{operand defined here (op in a parent region)}} %x = "bar"() : () -> i32 // expected-note {{operand defined here (op in a parent region)}}
return return
} }
// ----- // -----
func @dominance_failure() { // expected-note {{operand defined as a block argument (block #1 in the same region)}} func @dominance_failure() { // expected-note {{operand defined as a block argument (block #1 in the same region)}}
^bb0: ^bb0:
br ^bb1(%x : i32) // expected-error {{operand #0 does not dominate this use}} cf.br ^bb1(%x : i32) // expected-error {{operand #0 does not dominate this use}}
^bb1(%x : i32): ^bb1(%x : i32):
return return
} }
// ----- // -----
func @dominance_failure() { // expected-note {{operand defined as a block argument (block #1 in a parent region)}} func @dominance_failure() { // expected-note {{operand defined as a block argument (block #1 in a parent region)}}
^bb0: ^bb0:
%f = "foo"() ({ %f = "foo"() ({
"foo"(%x) : (i32) -> () // expected-error {{operand #0 does not dominate this use}} "foo"(%x) : (i32) -> () // expected-error {{operand #0 does not dominate this use}}
}) : () -> (i32) }) : () -> (i32)
br ^bb1(%f : i32) cf.br ^bb1(%f : i32)
^bb1(%x : i32): ^bb1(%x : i32):
return return
} }
// ----- // -----
func @return_type_mismatch() -> i32 { func @return_type_mismatch() -> i32 {
%0 = "foo"() : ()->f32 %0 = "foo"() : ()->f32
▲ Show 20 Lines • Show All 451 Lines • ▼ Show 20 Lines
func @negative_in_tensor_size() -> tensor<1x-1xi32> func @negative_in_tensor_size() -> tensor<1x-1xi32>
// ----- // -----
func @invalid_nested_dominance() { func @invalid_nested_dominance() {
"test.ssacfg_region"() ({ "test.ssacfg_region"() ({
// expected-error @+1 {{operand #0 does not dominate this use}} // expected-error @+1 {{operand #0 does not dominate this use}}
"foo.use" (%1) : (i32) -> () "foo.use" (%1) : (i32) -> ()
br ^bb2 cf.br ^bb2
^bb2: ^bb2:
// expected-note @+1 {{operand defined here}} // expected-note @+1 {{operand defined here}}
%1 = arith.constant 0 : i32 %1 = arith.constant 0 : i32
"foo.yield" () : () -> () "foo.yield" () : () -> ()
}) : () -> () }) : () -> ()
return return
} }
▲ Show 20 Lines • Show All 583 Lines • ▼ Show 20 Lines
// ----- // -----
// expected-error @+1 {{attribute 'attr' occurs more than once in the attribute list}} // expected-error @+1 {{attribute 'attr' occurs more than once in the attribute list}}
test.format_symbol_name_attr_op @name { attr = "xx" } test.format_symbol_name_attr_op @name { attr = "xx" }
// ----- // -----
func @forward_reference_type_check() -> (i8) { func @forward_reference_type_check() -> (i8) {
br ^bb2 cf.br ^bb2
^bb1: ^bb1:
// expected-note @+1 {{previously used here with type 'i8'}} // expected-note @+1 {{previously used here with type 'i8'}}
return %1 : i8 return %1 : i8
^bb2: ^bb2:
// expected-error @+1 {{definition of SSA value '%1#0' has type 'f32'}} // expected-error @+1 {{definition of SSA value '%1#0' has type 'f32'}}
%1 = "bar"() : () -> (f32) %1 = "bar"() : () -> (f32)
br ^bb1 cf.br ^bb1
} }
// ----- // -----
func @dominance_error_in_unreachable_op() -> i1 { func @dominance_error_in_unreachable_op() -> i1 {
%c = arith.constant false %c = arith.constant false
return %c : i1 return %c : i1
^bb0: ^bb0:
"test.ssacfg_region" () ({ // unreachable "test.ssacfg_region" () ({ // unreachable
^bb1: ^bb1:
// expected-error @+1 {{operand #0 does not dominate this use}} // expected-error @+1 {{operand #0 does not dominate this use}}
%2:3 = "bar"(%1) : (i64) -> (i1,i1,i1) %2:3 = "bar"(%1) : (i64) -> (i1,i1,i1)
br ^bb4 cf.br ^bb4
^bb2: ^bb2:
br ^bb2 cf.br ^bb2
^bb4: ^bb4:
%1 = "foo"() : ()->i64 // expected-note {{operand defined here}} %1 = "foo"() : ()->i64 // expected-note {{operand defined here}}
}) : () -> () }) : () -> ()
return %c : i1 return %c : i1
} }
// ----- // -----
Show All 17 Lines

mlir/test/IR/parser.mlir

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Lines^bb42 (%arg0: i32, %f: i64):
return return
// CHECK: } // CHECK: }
} }
// CHECK-LABEL: func @multiblock() { // CHECK-LABEL: func @multiblock() {
func @multiblock() { func @multiblock() {
return // CHECK: return return // CHECK: return
^bb1: // CHECK: ^bb1: // no predecessors ^bb1: // CHECK: ^bb1: // no predecessors
br ^bb4 // CHECK: br ^bb3 cf.br ^bb4 // CHECK: cf.br ^bb3
^bb2: // CHECK: ^bb2: // pred: ^bb2 ^bb2: // CHECK: ^bb2: // pred: ^bb2
br ^bb2 // CHECK: br ^bb2 cf.br ^bb2 // CHECK: cf.br ^bb2
^bb4: // CHECK: ^bb3: // pred: ^bb1 ^bb4: // CHECK: ^bb3: // pred: ^bb1
return // CHECK: return return // CHECK: return
} // CHECK: } } // CHECK: }
// CHECK-LABEL: func @emptyMLF() { // CHECK-LABEL: func @emptyMLF() {
func @emptyMLF() { func @emptyMLF() {
return // CHECK: return return // CHECK: return
} // CHECK: } } // CHECK: }
▲ Show 20 Lines • Show All 212 Lines • ▼ Show 20 Linesfunc @attributes() {
"foo"() {int = 0 : i42} : () -> () "foo"() {int = 0 : i42} : () -> ()
return return
} }
// CHECK-LABEL: func @ssa_values() -> (i16, i8) { // CHECK-LABEL: func @ssa_values() -> (i16, i8) {
func @ssa_values() -> (i16, i8) { func @ssa_values() -> (i16, i8) {
// CHECK: %{{.*}}:2 = "foo"() : () -> (i1, i17) // CHECK: %{{.*}}:2 = "foo"() : () -> (i1, i17)
%0:2 = "foo"() : () -> (i1, i17) %0:2 = "foo"() : () -> (i1, i17)
br ^bb2 cf.br ^bb2
^bb1: // CHECK: ^bb1: // pred: ^bb2 ^bb1: // CHECK: ^bb1: // pred: ^bb2
// CHECK: %{{.*}}:2 = "baz"(%{{.*}}#1, %{{.*}}#0, %{{.*}}#1) : (f32, i11, i17) -> (i16, i8) // CHECK: %{{.*}}:2 = "baz"(%{{.*}}#1, %{{.*}}#0, %{{.*}}#1) : (f32, i11, i17) -> (i16, i8)
%1:2 = "baz"(%2#1, %2#0, %0#1) : (f32, i11, i17) -> (i16, i8) %1:2 = "baz"(%2#1, %2#0, %0#1) : (f32, i11, i17) -> (i16, i8)
// CHECK: return %{{.*}}#0, %{{.*}}#1 : i16, i8 // CHECK: return %{{.*}}#0, %{{.*}}#1 : i16, i8
return %1#0, %1#1 : i16, i8 return %1#0, %1#1 : i16, i8
^bb2: // CHECK: ^bb2: // pred: ^bb0 ^bb2: // CHECK: ^bb2: // pred: ^bb0
// CHECK: %{{.*}}:2 = "bar"(%{{.*}}#0, %{{.*}}#1) : (i1, i17) -> (i11, f32) // CHECK: %{{.*}}:2 = "bar"(%{{.*}}#0, %{{.*}}#1) : (i1, i17) -> (i11, f32)
%2:2 = "bar"(%0#0, %0#1) : (i1, i17) -> (i11, f32) %2:2 = "bar"(%0#0, %0#1) : (i1, i17) -> (i11, f32)
br ^bb1 cf.br ^bb1
} }
// CHECK-LABEL: func @bbargs() -> (i16, i8) { // CHECK-LABEL: func @bbargs() -> (i16, i8) {
func @bbargs() -> (i16, i8) { func @bbargs() -> (i16, i8) {
// CHECK: %{{.*}}:2 = "foo"() : () -> (i1, i17) // CHECK: %{{.*}}:2 = "foo"() : () -> (i1, i17)
%0:2 = "foo"() : () -> (i1, i17) %0:2 = "foo"() : () -> (i1, i17)
br ^bb1(%0#1, %0#0 : i17, i1) cf.br ^bb1(%0#1, %0#0 : i17, i1)
^bb1(%x: i17, %y: i1): // CHECK: ^bb1(%{{.*}}: i17, %{{.*}}: i1): ^bb1(%x: i17, %y: i1): // CHECK: ^bb1(%{{.*}}: i17, %{{.*}}: i1):
// CHECK: %{{.*}}:2 = "baz"(%{{.*}}, %{{.*}}, %{{.*}}#1) : (i17, i1, i17) -> (i16, i8) // CHECK: %{{.*}}:2 = "baz"(%{{.*}}, %{{.*}}, %{{.*}}#1) : (i17, i1, i17) -> (i16, i8)
%1:2 = "baz"(%x, %y, %0#1) : (i17, i1, i17) -> (i16, i8) %1:2 = "baz"(%x, %y, %0#1) : (i17, i1, i17) -> (i16, i8)
return %1#0, %1#1 : i16, i8 return %1#0, %1#1 : i16, i8
} }
// CHECK-LABEL: func @verbose_terminators() -> (i1, i17) // CHECK-LABEL: func @verbose_terminators() -> (i1, i17)
func @verbose_terminators() -> (i1, i17) { func @verbose_terminators() -> (i1, i17) {
%0:2 = "foo"() : () -> (i1, i17) %0:2 = "foo"() : () -> (i1, i17)
// CHECK: br ^bb1(%{{.*}}#0, %{{.*}}#1 : i1, i17) // CHECK: cf.br ^bb1(%{{.*}}#0, %{{.*}}#1 : i1, i17)
"std.br"(%0#0, %0#1)[^bb1] : (i1, i17) -> () "cf.br"(%0#0, %0#1)[^bb1] : (i1, i17) -> ()
^bb1(%x : i1, %y : i17): ^bb1(%x : i1, %y : i17):
// CHECK: cond_br %{{.*}}, ^bb2(%{{.*}} : i17), ^bb3(%{{.*}}, %{{.*}} : i1, i17) // CHECK: cf.cond_br %{{.*}}, ^bb2(%{{.*}} : i17), ^bb3(%{{.*}}, %{{.*}} : i1, i17)
"std.cond_br"(%x, %y, %x, %y) [^bb2, ^bb3] {operand_segment_sizes = dense<[1, 1, 2]>: vector<3xi32>} : (i1, i17, i1, i17) -> () "cf.cond_br"(%x, %y, %x, %y) [^bb2, ^bb3] {operand_segment_sizes = dense<[1, 1, 2]>: vector<3xi32>} : (i1, i17, i1, i17) -> ()
^bb2(%a : i17): ^bb2(%a : i17):
%true = arith.constant true %true = arith.constant true
// CHECK: return %{{.*}}, %{{.*}} : i1, i17 // CHECK: return %{{.*}}, %{{.*}} : i1, i17
"std.return"(%true, %a) : (i1, i17) -> () "std.return"(%true, %a) : (i1, i17) -> ()
^bb3(%b : i1, %c : i17): ^bb3(%b : i1, %c : i17):
// CHECK: return %{{.*}}, %{{.*}} : i1, i17 // CHECK: return %{{.*}}, %{{.*}} : i1, i17
"std.return"(%b, %c) : (i1, i17) -> () "std.return"(%b, %c) : (i1, i17) -> ()
} }
// CHECK-LABEL: func @condbr_simple // CHECK-LABEL: func @condbr_simple
func @condbr_simple() -> (i32) { func @condbr_simple() -> (i32) {
%cond = "foo"() : () -> i1 %cond = "foo"() : () -> i1
%a = "bar"() : () -> i32 %a = "bar"() : () -> i32
%b = "bar"() : () -> i64 %b = "bar"() : () -> i64
// CHECK: cond_br %{{.*}}, ^bb1(%{{.*}} : i32), ^bb2(%{{.*}} : i64) // CHECK: cf.cond_br %{{.*}}, ^bb1(%{{.*}} : i32), ^bb2(%{{.*}} : i64)
cond_br %cond, ^bb1(%a : i32), ^bb2(%b : i64) cf.cond_br %cond, ^bb1(%a : i32), ^bb2(%b : i64)
// CHECK: ^bb1({{.*}}: i32): // pred: ^bb0 // CHECK: ^bb1({{.*}}: i32): // pred: ^bb0
^bb1(%x : i32): ^bb1(%x : i32):
br ^bb2(%b: i64) cf.br ^bb2(%b: i64)
// CHECK: ^bb2({{.*}}: i64): // 2 preds: ^bb0, ^bb1 // CHECK: ^bb2({{.*}}: i64): // 2 preds: ^bb0, ^bb1
^bb2(%y : i64): ^bb2(%y : i64):
%z = "foo"() : () -> i32 %z = "foo"() : () -> i32
return %z : i32 return %z : i32
} }
// CHECK-LABEL: func @condbr_moarargs // CHECK-LABEL: func @condbr_moarargs
func @condbr_moarargs() -> (i32) { func @condbr_moarargs() -> (i32) {
%cond = "foo"() : () -> i1 %cond = "foo"() : () -> i1
%a = "bar"() : () -> i32 %a = "bar"() : () -> i32
%b = "bar"() : () -> i64 %b = "bar"() : () -> i64
// CHECK: cond_br %{{.*}}, ^bb1(%{{.*}}, %{{.*}} : i32, i64), ^bb2(%{{.*}}, %{{.*}}, %{{.*}} : i64, i32, i32) // CHECK: cf.cond_br %{{.*}}, ^bb1(%{{.*}}, %{{.*}} : i32, i64), ^bb2(%{{.*}}, %{{.*}}, %{{.*}} : i64, i32, i32)
cond_br %cond, ^bb1(%a, %b : i32, i64), ^bb2(%b, %a, %a : i64, i32, i32) cf.cond_br %cond, ^bb1(%a, %b : i32, i64), ^bb2(%b, %a, %a : i64, i32, i32)
^bb1(%x : i32, %y : i64): ^bb1(%x : i32, %y : i64):
return %x : i32 return %x : i32
^bb2(%x2 : i64, %y2 : i32, %z2 : i32): ^bb2(%x2 : i64, %y2 : i32, %z2 : i32):
%z = "foo"() : () -> i32 %z = "foo"() : () -> i32
return %z : i32 return %z : i32
} }
▲ Show 20 Lines • Show All 775 Lines • ▼ Show 20 Lines test.default_dialect {
test.parse_integer_literal : 6 test.parse_integer_literal : 6
// Verify that only an op prefix is stripped, not an attribute value for // Verify that only an op prefix is stripped, not an attribute value for
// example. // example.
// CHECK: "test.op_with_attr"() {test.attr = "test.value"} : () -> () // CHECK: "test.op_with_attr"() {test.attr = "test.value"} : () -> ()
"test.op_with_attr"() {test.attr = "test.value"} : () -> () "test.op_with_attr"() {test.attr = "test.value"} : () -> ()
// TODO: remove this after removing the special casing for std in the printer. // TODO: remove this after removing the special casing for std in the printer.
// Verify that operations in the standard dialect keep the `std.` prefix. // Verify that operations in the standard dialect keep the `std.` prefix.
// CHECK: std.assert // CHECK: cf.assert
assert %bool, "Assertion" cf.assert %bool, "Assertion"
"test.terminator"() : ()->() "test.terminator"() : ()->()
} }
// The same operation outside of the region does not have an std. prefix. // The same operation outside of the region does not have an std. prefix.
// CHECK-NOT: std.assert // CHECK-NOT: std.assert
// CHECK: assert // CHECK: return
assert %bool, "Assertion" std.return
return
} }
// CHECK-LABEL: func @unreachable_dominance_violation_ok // CHECK-LABEL: func @unreachable_dominance_violation_ok
func @unreachable_dominance_violation_ok() -> i1 { func @unreachable_dominance_violation_ok() -> i1 {
// CHECK: [[VAL:%.*]] = arith.constant false // CHECK: [[VAL:%.*]] = arith.constant false
// CHECK: return [[VAL]] : i1 // CHECK: return [[VAL]] : i1
// CHECK: ^bb1: // no predecessors // CHECK: ^bb1: // no predecessors
// CHECK: [[VAL2:%.*]]:3 = "bar"([[VAL3:%.*]]) : (i64) -> (i1, i1, i1) // CHECK: [[VAL2:%.*]]:3 = "bar"([[VAL3:%.*]]) : (i64) -> (i1, i1, i1)
// CHECK: br ^bb3 // CHECK: cf.br ^bb3
// CHECK: ^bb2: // pred: ^bb2 // CHECK: ^bb2: // pred: ^bb2
// CHECK: br ^bb2 // CHECK: cf.br ^bb2
// CHECK: ^bb3: // pred: ^bb1 // CHECK: ^bb3: // pred: ^bb1
// CHECK: [[VAL3]] = "foo"() : () -> i64 // CHECK: [[VAL3]] = "foo"() : () -> i64
// CHECK: return [[VAL2]]#1 : i1 // CHECK: return [[VAL2]]#1 : i1
// CHECK: } // CHECK: }
%c = arith.constant false %c = arith.constant false
return %c : i1 return %c : i1
^bb1: ^bb1:
// %1 is not dominated by it's definition, but block is not reachable. // %1 is not dominated by it's definition, but block is not reachable.
%2:3 = "bar"(%1) : (i64) -> (i1,i1,i1) %2:3 = "bar"(%1) : (i64) -> (i1,i1,i1)
br ^bb3 cf.br ^bb3
^bb2: ^bb2:
br ^bb2 cf.br ^bb2
^bb3: ^bb3:
%1 = "foo"() : ()->i64 %1 = "foo"() : ()->i64
return %2#1 : i1 return %2#1 : i1
} }
// CHECK-LABEL: func @graph_region_in_hierarchy_ok // CHECK-LABEL: func @graph_region_in_hierarchy_ok
func @graph_region_in_hierarchy_ok() -> i64 { func @graph_region_in_hierarchy_ok() -> i64 {
// CHECK: br ^bb2 // CHECK: cf.br ^bb2
// CHECK: ^bb1: // CHECK: ^bb1:
// CHECK: test.graph_region { // CHECK: test.graph_region {
// CHECK: [[VAL2:%.*]]:3 = "bar"([[VAL3:%.*]]) : (i64) -> (i1, i1, i1) // CHECK: [[VAL2:%.*]]:3 = "bar"([[VAL3:%.*]]) : (i64) -> (i1, i1, i1)
// CHECK: } // CHECK: }
// CHECK: br ^bb3 // CHECK: cf.br ^bb3
// CHECK: ^bb2: // pred: ^bb0 // CHECK: ^bb2: // pred: ^bb0
// CHECK: [[VAL3]] = "foo"() : () -> i64 // CHECK: [[VAL3]] = "foo"() : () -> i64
// CHECK: br ^bb1 // CHECK: cf.br ^bb1
// CHECK: ^bb3: // pred: ^bb1 // CHECK: ^bb3: // pred: ^bb1
// CHECK: return [[VAL3]] : i64 // CHECK: return [[VAL3]] : i64
// CHECK: } // CHECK: }
br ^bb2 cf.br ^bb2
^bb1: ^bb1:
test.graph_region { test.graph_region {
// %1 is well-defined here, since bb2 dominates bb1. // %1 is well-defined here, since bb2 dominates bb1.
%2:3 = "bar"(%1) : (i64) -> (i1,i1,i1) %2:3 = "bar"(%1) : (i64) -> (i1,i1,i1)
} }
br ^bb4 cf.br ^bb4
^bb2: ^bb2:
%1 = "foo"() : ()->i64 %1 = "foo"() : ()->i64
br ^bb1 cf.br ^bb1
^bb4: ^bb4:
return %1 : i64 return %1 : i64
} }
// CHECK-LABEL: func @graph_region_kind // CHECK-LABEL: func @graph_region_kind
func @graph_region_kind() -> () { func @graph_region_kind() -> () {
// CHECK: [[VAL2:%.*]]:3 = "bar"([[VAL3:%.*]]) : (i64) -> (i1, i1, i1) // CHECK: [[VAL2:%.*]]:3 = "bar"([[VAL3:%.*]]) : (i64) -> (i1, i1, i1)
// CHECK: [[VAL3]] = "baz"([[VAL2]]#0) : (i1) -> i64 // CHECK: [[VAL3]] = "baz"([[VAL2]]#0) : (i1) -> i64
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

mlir/test/IR/region.mlir

Show All 40 Lines
// Test SizedRegion // Test SizedRegion
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @unnamed_region_has_wrong_number_of_blocks() { func @unnamed_region_has_wrong_number_of_blocks() {
// expected-error@+1 {{region #1 failed to verify constraint: region with 1 blocks}} // expected-error@+1 {{region #1 failed to verify constraint: region with 1 blocks}}
"test.sized_region_op"() ( "test.sized_region_op"() (
{ {
"work"() : () -> () "work"() : () -> ()
br ^next1 cf.br ^next1
^next1: ^next1:
"work"() : () -> () "work"() : () -> ()
}, },
{ {
"work"() : () -> () "work"() : () -> ()
br ^next2 cf.br ^next2
^next2: ^next2:
"work"() : () -> () "work"() : () -> ()
}) : () -> () }) : () -> ()
return return
} }
// ----- // -----
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

mlir/test/IR/traits.mlir

Show First 20 Lines • Show All 523 Lines • ▼ Show 20 Lines
// Ensure that SSACFG regions of operations in GRAPH regions are // Ensure that SSACFG regions of operations in GRAPH regions are
// checked for dominance // checked for dominance
func @illegalCDFGInsideDominanceFreeScope() -> () { func @illegalCDFGInsideDominanceFreeScope() -> () {
test.graph_region { test.graph_region {
builtin.func @test() -> i1 { builtin.func @test() -> i1 {
^bb1: ^bb1:
// expected-error @+1 {{operand #0 does not dominate this use}} // expected-error @+1 {{operand #0 does not dominate this use}}
%2:3 = "bar"(%1) : (i64) -> (i1,i1,i1) %2:3 = "bar"(%1) : (i64) -> (i1,i1,i1)
br ^bb4 cf.br ^bb4
^bb2: ^bb2:
br ^bb2 cf.br ^bb2
^bb4: ^bb4:
%1 = "foo"() : ()->i64 // expected-note {{operand defined here}} %1 = "foo"() : ()->i64 // expected-note {{operand defined here}}
return %2#1 : i1 return %2#1 : i1
} }
"terminator"() : () -> () "terminator"() : () -> ()
} }
return return
} }
Show All 11 Lines
} }
// ----- // -----
func @graph_region_cant_have_blocks() { func @graph_region_cant_have_blocks() {
test.graph_region { test.graph_region {
// expected-error@-1 {{'test.graph_region' op expects graph region #0 to have 0 or 1 blocks}} // expected-error@-1 {{'test.graph_region' op expects graph region #0 to have 0 or 1 blocks}}
^bb42: ^bb42:
br ^bb43 cf.br ^bb43
^bb43: ^bb43:
"terminator"() : () -> () "terminator"() : () -> ()
} }
} }
// ----- // -----
// Check that we can query traits in types // Check that we can query traits in types
Show All 24 Lines
// ----- // -----
// Check that we can query traits in attributes // Check that we can query traits in attributes
func @failed_attr_traits() { func @failed_attr_traits() {
// expected-error@+1 {{'attr' attribute should have trait 'TestAttrTrait'}} // expected-error@+1 {{'attr' attribute should have trait 'TestAttrTrait'}}
"test.attr_with_trait"() {attr = 42 : i32} : () -> () "test.attr_with_trait"() {attr = 42 : i32} : () -> ()
return return
} }
No newline at end of file No newline at end of file

mlir/test/IR/visitors.mlir

Show First 20 Lines • Show All 110 Lines • ▼ Show 20 Lines
// CHECK: Erasing block ^bb0 from region 0 from operation 'builtin.module' // CHECK: Erasing block ^bb0 from region 0 from operation 'builtin.module'
// ----- // -----
func @unstructured_cfg() { func @unstructured_cfg() {
"regionOp0"() ({ "regionOp0"() ({
^bb0: ^bb0:
"op0"() : () -> () "op0"() : () -> ()
br ^bb2 cf.br ^bb2
^bb1: ^bb1:
"op1"() : () -> () "op1"() : () -> ()
br ^bb2 cf.br ^bb2
^bb2: ^bb2:
"op2"() : () -> () "op2"() : () -> ()
}) : () -> () }) : () -> ()
return return
} }
// CHECK-LABEL: Op pre-order visits // CHECK-LABEL: Op pre-order visits
// CHECK: Visiting op 'builtin.module' // CHECK: Visiting op 'builtin.module'
// CHECK: Visiting op 'builtin.func' // CHECK: Visiting op 'builtin.func'
// CHECK: Visiting op 'regionOp0' // CHECK: Visiting op 'regionOp0'
// CHECK: Visiting op 'op0' // CHECK: Visiting op 'op0'
// CHECK: Visiting op 'std.br' // CHECK: Visiting op 'cf.br'
// CHECK: Visiting op 'op1' // CHECK: Visiting op 'op1'
// CHECK: Visiting op 'std.br' // CHECK: Visiting op 'cf.br'
// CHECK: Visiting op 'op2' // CHECK: Visiting op 'op2'
// CHECK: Visiting op 'std.return' // CHECK: Visiting op 'std.return'
// CHECK-LABEL: Block pre-order visits // CHECK-LABEL: Block pre-order visits
// CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.module' // CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.module'
// CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.func' // CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.func'
// CHECK: Visiting block ^bb0 from region 0 from operation 'regionOp0' // CHECK: Visiting block ^bb0 from region 0 from operation 'regionOp0'
// CHECK: Visiting block ^bb1 from region 0 from operation 'regionOp0' // CHECK: Visiting block ^bb1 from region 0 from operation 'regionOp0'
// CHECK: Visiting block ^bb2 from region 0 from operation 'regionOp0' // CHECK: Visiting block ^bb2 from region 0 from operation 'regionOp0'
// CHECK-LABEL: Region pre-order visits // CHECK-LABEL: Region pre-order visits
// CHECK: Visiting region 0 from operation 'builtin.module' // CHECK: Visiting region 0 from operation 'builtin.module'
// CHECK: Visiting region 0 from operation 'builtin.func' // CHECK: Visiting region 0 from operation 'builtin.func'
// CHECK: Visiting region 0 from operation 'regionOp0' // CHECK: Visiting region 0 from operation 'regionOp0'
// CHECK-LABEL: Op post-order visits // CHECK-LABEL: Op post-order visits
// CHECK: Visiting op 'op0' // CHECK: Visiting op 'op0'
// CHECK: Visiting op 'std.br' // CHECK: Visiting op 'cf.br'
// CHECK: Visiting op 'op1' // CHECK: Visiting op 'op1'
// CHECK: Visiting op 'std.br' // CHECK: Visiting op 'cf.br'
// CHECK: Visiting op 'op2' // CHECK: Visiting op 'op2'
// CHECK: Visiting op 'regionOp0' // CHECK: Visiting op 'regionOp0'
// CHECK: Visiting op 'std.return' // CHECK: Visiting op 'std.return'
// CHECK: Visiting op 'builtin.func' // CHECK: Visiting op 'builtin.func'
// CHECK: Visiting op 'builtin.module' // CHECK: Visiting op 'builtin.module'
// CHECK-LABEL: Block post-order visits // CHECK-LABEL: Block post-order visits
// CHECK: Visiting block ^bb0 from region 0 from operation 'regionOp0' // CHECK: Visiting block ^bb0 from region 0 from operation 'regionOp0'
Show All 13 Lines
// CHECK-LABEL: Block pre-order erasures (skip) // CHECK-LABEL: Block pre-order erasures (skip)
// CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0' // CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0'
// CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0' // CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0'
// CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0' // CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0'
// CHECK-LABEL: Op post-order erasures (skip) // CHECK-LABEL: Op post-order erasures (skip)
// CHECK: Erasing op 'op0' // CHECK: Erasing op 'op0'
// CHECK: Erasing op 'std.br' // CHECK: Erasing op 'cf.br'
// CHECK: Erasing op 'op1' // CHECK: Erasing op 'op1'
// CHECK: Erasing op 'std.br' // CHECK: Erasing op 'cf.br'
// CHECK: Erasing op 'op2' // CHECK: Erasing op 'op2'
// CHECK: Erasing op 'regionOp0' // CHECK: Erasing op 'regionOp0'
// CHECK: Erasing op 'std.return' // CHECK: Erasing op 'std.return'
// CHECK-LABEL: Block post-order erasures (skip) // CHECK-LABEL: Block post-order erasures (skip)
// CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0' // CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0'
// CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0' // CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0'
// CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0' // CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0'
// CHECK-LABEL: Op post-order erasures (no skip) // CHECK-LABEL: Op post-order erasures (no skip)
// CHECK: Erasing op 'op0' // CHECK: Erasing op 'op0'
// CHECK: Erasing op 'std.br' // CHECK: Erasing op 'cf.br'
// CHECK: Erasing op 'op1' // CHECK: Erasing op 'op1'
// CHECK: Erasing op 'std.br' // CHECK: Erasing op 'cf.br'
// CHECK: Erasing op 'op2' // CHECK: Erasing op 'op2'
// CHECK: Erasing op 'regionOp0' // CHECK: Erasing op 'regionOp0'
// CHECK: Erasing op 'std.return' // CHECK: Erasing op 'std.return'
// CHECK-LABEL: Block post-order erasures (no skip) // CHECK-LABEL: Block post-order erasures (no skip)
// CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0' // CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0'
// CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0' // CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0'
// CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0' // CHECK: Erasing block ^bb0 from region 0 from operation 'regionOp0'
// CHECK: Erasing block ^bb0 from region 0 from operation 'builtin.func' // CHECK: Erasing block ^bb0 from region 0 from operation 'builtin.func'
// CHECK: Erasing block ^bb0 from region 0 from operation 'builtin.module' // CHECK: Erasing block ^bb0 from region 0 from operation 'builtin.module'

mlir/test/Integration/Dialect/Async/CPU/microbench-linalg-async-parallel-for.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: -convert-linalg-to-parallel-loops \ // RUN: -convert-linalg-to-parallel-loops \
// RUN: -async-parallel-for \ // RUN: -async-parallel-for \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -memref-expand \ // RUN: -memref-expand \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O3 \ // RUN: -e entry -entry-point-result=void -O3 \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: -convert-linalg-to-loops \ // RUN: -convert-linalg-to-loops \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O3 \ // RUN: -e entry -entry-point-result=void -O3 \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Async/CPU/microbench-scf-async-parallel-for.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: -async-parallel-for \ // RUN: -async-parallel-for \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-linalg-to-loops \ // RUN: -convert-linalg-to-loops \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -memref-expand \ // RUN: -memref-expand \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O3 \ // RUN: -e entry -entry-point-result=void -O3 \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: -async-parallel-for=async-dispatch=false \ // RUN: -async-parallel-for=async-dispatch=false \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-linalg-to-loops \ // RUN: -convert-linalg-to-loops \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -memref-expand \ // RUN: -memref-expand \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O3 \ // RUN: -e entry -entry-point-result=void -O3 \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: -convert-linalg-to-loops \ // RUN: -convert-linalg-to-loops \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O3 \ // RUN: -e entry -entry-point-result=void -O3 \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Async/CPU/test-async-parallel-for-1d.mlir

// RUN: mlir-opt %s -async-parallel-for \ // RUN: mlir-opt %s -async-parallel-for \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -memref-expand \ // RUN: -memref-expand \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O0 \ // RUN: -e entry -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// RUN: mlir-opt %s -async-parallel-for \ // RUN: mlir-opt %s -async-parallel-for \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-policy-based-ref-counting \ // RUN: -async-runtime-policy-based-ref-counting \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -memref-expand \ // RUN: -memref-expand \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O0 \ // RUN: -e entry -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// RUN: mlir-opt %s -async-parallel-for="async-dispatch=false \ // RUN: mlir-opt %s -async-parallel-for="async-dispatch=false \
// RUN: num-workers=20 \ // RUN: num-workers=20 \
// RUN: min-task-size=1" \ // RUN: min-task-size=1" \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -memref-expand \ // RUN: -memref-expand \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O0 \ // RUN: -e entry -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Linesfunc @entry() {
call @print_memref_f32(%U): (memref<*xf32>) -> () call @print_memref_f32(%U): (memref<*xf32>) -> ()
// 4. Check that loop with zero iterations doesn't crash at runtime. // 4. Check that loop with zero iterations doesn't crash at runtime.
%lb1 = call @zero(): () -> (index) %lb1 = call @zero(): () -> (index)
%ub1 = call @zero(): () -> (index) %ub1 = call @zero(): () -> (index)
scf.parallel (%i) = (%lb1) to (%ub1) step (%c1) { scf.parallel (%i) = (%lb1) to (%ub1) step (%c1) {
%false = arith.constant 0 : i1 %false = arith.constant 0 : i1
assert %false, "should never be executed" cf.assert %false, "should never be executed"
} }
memref.dealloc %A : memref<9xf32> memref.dealloc %A : memref<9xf32>
return return
} }
func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface } func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }

mlir/test/Integration/Dialect/Async/CPU/test-async-parallel-for-2d.mlir

// RUN: mlir-opt %s -async-parallel-for \ // RUN: mlir-opt %s -async-parallel-for \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O0 \ // RUN: -e entry -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// RUN: mlir-opt %s -async-parallel-for \ // RUN: mlir-opt %s -async-parallel-for \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-policy-based-ref-counting \ // RUN: -async-runtime-policy-based-ref-counting \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O0 \ // RUN: -e entry -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// RUN: mlir-opt %s -async-parallel-for="async-dispatch=false \ // RUN: mlir-opt %s -async-parallel-for="async-dispatch=false \
// RUN: num-workers=20 \ // RUN: num-workers=20 \
// RUN: min-task-size=1" \ // RUN: min-task-size=1" \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O0 \ // RUN: -e entry -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/benchmark_matmul.mlir

// RUN: export M=24 && export K=64 && export N=192 && export ITERS=10 && \ // RUN: export M=24 && export K=64 && export N=192 && export ITERS=10 && \
// RUN: cat %s | sed 's@${M}@'"$M"'@g'| sed 's@${K}@'"$K"'@g' | sed 's@${N}@'"$N"'@g'| sed 's@${ITERS}@'"$ITERS"'@g'| \ // RUN: cat %s | sed 's@${M}@'"$M"'@g'| sed 's@${K}@'"$K"'@g' | sed 's@${N}@'"$N"'@g'| sed 's@${ITERS}@'"$ITERS"'@g'| \
// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul register-tile-sizes=12,32,16 vectorize" | \ // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul register-tile-sizes=12,32,16 vectorize" | \
// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.fill register-tile-sizes=4,32 vectorize" | \ // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.fill register-tile-sizes=4,32 vectorize" | \
// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=memref.copy register-tile-sizes=4,32 vectorize" | \ // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=memref.copy register-tile-sizes=4,32 vectorize" | \
// RUN: mlir-opt -canonicalize -convert-vector-to-scf -lower-affine -convert-linalg-to-loops | \ // RUN: mlir-opt -canonicalize -convert-vector-to-scf -lower-affine -convert-linalg-to-loops | \
// RUN: mlir-opt -canonicalize -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt -canonicalize -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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 \
// Activate to dump assembly // Activate to dump assembly
// R_UN: -dump-object-file -object-filename=/tmp/a.o \ // R_UN: -dump-object-file -object-filename=/tmp/a.o \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// Use tee to both print to stderr and FileCheck // Use tee to both print to stderr and FileCheck
// RUN: tee -a /dev/stderr | FileCheck %s // RUN: tee -a /dev/stderr | FileCheck %s
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/matmul-vs-matvec.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(memref<*xf32>)
func @matmul(%A: memref<?x?xf32>, %B: memref<?x?xf32>) -> (memref<?x?xf32>) { func @matmul(%A: memref<?x?xf32>, %B: memref<?x?xf32>) -> (memref<?x?xf32>) {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linesfunc @main() {
memref.store %val1, %B[%c0, %c0] : memref<?x?xf32> memref.store %val1, %B[%c0, %c0] : memref<?x?xf32>
%C1 = call @matmul(%A, %B) : (memref<?x?xf32>, memref<?x?xf32>) -> memref<?x?xf32> %C1 = call @matmul(%A, %B) : (memref<?x?xf32>, memref<?x?xf32>) -> memref<?x?xf32>
%C2 = call @matvec(%A, %B) : (memref<?x?xf32>, memref<?x?xf32>) -> memref<?x?xf32> %C2 = call @matvec(%A, %B) : (memref<?x?xf32>, memref<?x?xf32>) -> memref<?x?xf32>
scf.for %i = %c0 to %m step %c1 { scf.for %i = %c0 to %m step %c1 {
scf.for %j = %c0 to %n step %c1 { scf.for %j = %c0 to %n step %c1 {
%e1 = memref.load %C1[%i, %j] : memref<?x?xf32> %e1 = memref.load %C1[%i, %j] : memref<?x?xf32>
%e2 = memref.load %C2[%i, %j] : memref<?x?xf32> %e2 = memref.load %C2[%i, %j] : memref<?x?xf32>
%c = arith.cmpf oeq, %e1, %e2 : f32 %c = arith.cmpf oeq, %e1, %e2 : f32
assert %c, "Matmul does not produce same output as matvec" cf.assert %c, "Matmul does not produce same output as matvec"
} }
} }
%C2_ = memref.cast %C2 : memref<?x?xf32> to memref<*xf32> %C2_ = memref.cast %C2 : memref<?x?xf32> to memref<*xf32>
call @print_memref_f32(%C2_) : (memref<*xf32>) -> () call @print_memref_f32(%C2_) : (memref<*xf32>) -> ()
memref.dealloc %C1 : memref<?x?xf32> memref.dealloc %C1 : memref<?x?xf32>
memref.dealloc %C2 : memref<?x?xf32> memref.dealloc %C2 : memref<?x?xf32>
return return
} }
Show All 9 Lines

mlir/test/Integration/Dialect/Linalg/CPU/rank-reducing-subview.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(memref<*xf32>)
func @main() { func @main() {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
Show All 30 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-comprehensive-bufferize.mlir

// RUN: mlir-opt %s -canonicalize -cse -linalg-comprehensive-module-bufferize |\ // RUN: mlir-opt %s -canonicalize -cse -linalg-comprehensive-module-bufferize |\
// RUN: mlir-opt -buffer-deallocation -convert-vector-to-scf -lower-affine -convert-linalg-to-loops |\ // RUN: mlir-opt -buffer-deallocation -convert-vector-to-scf -lower-affine -convert-linalg-to-loops |\
// RUN: mlir-opt -canonicalize -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt -canonicalize -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext |\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext,%mlir_integration_test_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/Linalg/CPU/test-conv-1d-call.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="tile-sizes=4" -convert-linalg-to-loops -convert-scf-to-std \ // RUN: mlir-opt %s -linalg-tile="tile-sizes=4" -convert-linalg-to-loops -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(memref<*xf32>)
// Creates and returns a 1-D buffer of size %s1 filled with the value %f // Creates and returns a 1-D buffer of size %s1 filled with the value %f
func @alloc_1d_filled_f32(%s1 : index, %f : f32) -> memref<?xf32> { func @alloc_1d_filled_f32(%s1 : index, %f : f32) -> memref<?xf32> {
Show All 36 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-nwc-wcf-call.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="tile-sizes=2,4" -convert-linalg-to-loops -convert-scf-to-std \ // RUN: mlir-opt %s -linalg-tile="tile-sizes=2,4" -convert-linalg-to-loops -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(memref<*xf32>)
// Creates and returns 3-D buffer of size (%s1, %s2, %s3) filled with the value %f // Creates and returns 3-D buffer of size (%s1, %s2, %s3) filled with the value %f
func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> memref<?x?x?xf32> { func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> memref<?x?x?xf32> {
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-call.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="tile-sizes=2,2" -convert-linalg-to-loops -convert-scf-to-std \ // RUN: mlir-opt %s -linalg-tile="tile-sizes=2,2" -convert-linalg-to-loops -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(memref<*xf32>)
// Creates and returns a 2-D buffer of size (%s1, %s2) filled with the value %f // Creates and returns a 2-D buffer of size (%s1, %s2) filled with the value %f
func @alloc_2d_filled_f32(%s1 : index, %s2 : index, %f : f32) -> memref<?x?xf32> { func @alloc_2d_filled_f32(%s1 : index, %s2 : index, %f : f32) -> memref<?x?xf32> {
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-nhwc-hwcf-call.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="tile-sizes=2,3,3,2" -convert-linalg-to-loops -convert-scf-to-std \ // RUN: mlir-opt %s -linalg-tile="tile-sizes=2,3,3,2" -convert-linalg-to-loops -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(memref<*xf32>)
// Creates and returns 4-D buffer of size (%s1, %s2, %s3, %s4) filled with the value %f // Creates and returns 4-D buffer of size (%s1, %s2, %s3, %s4) filled with the value %f
func @alloc_4d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %f : f32) -> memref<?x?x?x?xf32> { func @alloc_4d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %f : f32) -> memref<?x?x?x?xf32> {
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-call.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="tile-sizes=2,2,2" -convert-linalg-to-loops -convert-scf-to-std \ // RUN: mlir-opt %s -linalg-tile="tile-sizes=2,2,2" -convert-linalg-to-loops -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(memref<*xf32>)
// Creates and returns 3-D buffer of size (%s1, %s2, %s3) filled with the value %f // Creates and returns 3-D buffer of size (%s1, %s2, %s3) filled with the value %f
func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> memref<?x?x?xf32> { func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> memref<?x?x?xf32> {
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-ndhwc-dhwcf-call.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="tile-sizes=0,5,5,5" -convert-linalg-to-loops -convert-scf-to-std \ // RUN: mlir-opt %s -linalg-tile="tile-sizes=0,5,5,5" -convert-linalg-to-loops -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(memref<*xf32>)
// Creates and returns 5-D buffer of size (%s1, %s2, %s3, %s4, %s5) filled with the value %f // Creates and returns 5-D buffer of size (%s1, %s2, %s3, %s4, %s5) filled with the value %f
func @alloc_5d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %s5 : index, %f : f32) -> memref<?x?x?x?x?xf32> { func @alloc_5d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %s5 : index, %f : f32) -> memref<?x?x?x?x?xf32> {
▲ Show 20 Lines • Show All 166 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-padtensor.mlir

// RUN: mlir-opt %s -linalg-bufferize \ // RUN: mlir-opt %s -linalg-bufferize \
// RUN: -arith-bufferize -tensor-bufferize -func-bufferize \ // RUN: -arith-bufferize -tensor-bufferize -func-bufferize \
// RUN: -finalizing-bufferize -buffer-deallocation \ // RUN: -finalizing-bufferize -buffer-deallocation \
// RUN: -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @main() { func @main() {
%const = arith.constant dense<[[[1.0, 2.0, 3.0], [2.0, 3.0, 4.0]]]> : tensor<1x2x3xf32> %const = arith.constant dense<[[[1.0, 2.0, 3.0], [2.0, 3.0, 4.0]]]> : tensor<1x2x3xf32>
%dynamic = tensor.cast %const: tensor<1x2x3xf32> to tensor<1x?x3xf32> %dynamic = tensor.cast %const: tensor<1x2x3xf32> to tensor<1x?x3xf32>
Show All 21 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-subtensor-insert-multiple-uses.mlir

// RUN: mlir-opt %s -linalg-bufferize \ // RUN: mlir-opt %s -linalg-bufferize \
// RUN: -arith-bufferize -tensor-bufferize -func-bufferize \ // RUN: -arith-bufferize -tensor-bufferize -func-bufferize \
// RUN: -finalizing-bufferize -buffer-deallocation \ // RUN: -finalizing-bufferize -buffer-deallocation \
// RUN: -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @main() { func @main() {
%const = arith.constant dense<10.0> : tensor<2xf32> %const = arith.constant dense<10.0> : tensor<2xf32>
%insert_val = arith.constant dense<20.0> : tensor<1xf32> %insert_val = arith.constant dense<20.0> : tensor<1xf32>
Show All 25 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-subtensor-insert.mlir

// RUN: mlir-opt %s -linalg-bufferize \ // RUN: mlir-opt %s -linalg-bufferize \
// RUN: -arith-bufferize -tensor-bufferize -func-bufferize \ // RUN: -arith-bufferize -tensor-bufferize -func-bufferize \
// RUN: -finalizing-bufferize -buffer-deallocation \ // RUN: -finalizing-bufferize -buffer-deallocation \
// RUN: -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @main() { func @main() {
%const = arith.constant dense<10.0> : tensor<2xf32> %const = arith.constant dense<10.0> : tensor<2xf32>
%insert_val = arith.constant dense<20.0> : tensor<1xf32> %insert_val = arith.constant dense<20.0> : tensor<1xf32>
%inserted = tensor.insert_slice %insert_val into %const[0][1][1] : tensor<1xf32> into tensor<2xf32> %inserted = tensor.insert_slice %insert_val into %const[0][1][1] : tensor<1xf32> into tensor<2xf32>
Show All 12 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-tensor-matmul.mlir

// UNSUPPORTED: asan // UNSUPPORTED: asan
// RUN: mlir-opt %s -linalg-bufferize -arith-bufferize \ // RUN: mlir-opt %s -linalg-bufferize -arith-bufferize \
// RUN: -tensor-bufferize -func-bufferize -finalizing-bufferize -buffer-deallocation -convert-linalg-to-loops -convert-scf-to-std \ // RUN: -tensor-bufferize -func-bufferize -finalizing-bufferize -buffer-deallocation -convert-linalg-to-loops -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="tile-sizes=1,2,3" -linalg-bufferize \ // RUN: mlir-opt %s -linalg-tile="tile-sizes=1,2,3" -linalg-bufferize \
// RUN: -scf-bufferize -arith-bufferize -tensor-bufferize \ // RUN: -scf-bufferize -arith-bufferize -tensor-bufferize \
// RUN: -func-bufferize \ // RUN: -func-bufferize \
// RUN: -finalizing-bufferize -convert-linalg-to-loops -convert-scf-to-std -convert-scf-to-std \ // RUN: -finalizing-bufferize -convert-linalg-to-loops -convert-scf-to-cf -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-cf --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @main() { func @main() {
%A = arith.constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf32> %A = arith.constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf32>
%B = arith.constant dense<[[1.0, 2.0, 3.0, 4.0], %B = arith.constant dense<[[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0], [5.0, 6.0, 7.0, 8.0],
Show All 18 Lines

mlir/test/Integration/Dialect/Memref/memref_abi.c

// Split the MLIR string: this will produce %t/input.mlir // Split the MLIR string: this will produce %t/input.mlir
// RUN: split-file %s %t // RUN: split-file %s %t
// Compile the MLIR file to LLVM: // Compile the MLIR file to LLVM:
// RUN: mlir-opt %t/input.mlir \ // RUN: mlir-opt %t/input.mlir \
// RUN: -lower-affine -convert-scf-to-std -convert-memref-to-llvm \ // RUN: -lower-affine -convert-scf-to-cf -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm -reconcile-unrealized-casts \ // RUN: -convert-std-to-llvm -reconcile-unrealized-casts \
// RUN: | mlir-translate --mlir-to-llvmir -o %t.ll // RUN: | mlir-translate --mlir-to-llvmir -o %t.ll
// Generate an object file for the MLIR code // Generate an object file for the MLIR code
// RUN: llc %t.ll -o %t.o -filetype=obj // RUN: llc %t.ll -o %t.o -filetype=obj
// Compile the current C file and link it to the MLIR code: // Compile the current C file and link it to the MLIR code:
// RUN: %host_cc %s %t.o -o %t.exe // RUN: %host_cc %s %t.o -o %t.exe
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/taco/tools/mlir_pytaco_utils.py

Show First 20 Lines • Show All 152 Lines • ▼ Show 20 Linesdef compile_and_build_engine(
Returns: Returns:
A JIT execution engine for the MLIR module. A JIT execution engine for the MLIR module.
""" """
pipeline = ( pipeline = (
f"sparsification," f"sparsification,"
f"sparse-tensor-conversion," f"sparse-tensor-conversion,"
f"builtin.func(linalg-bufferize,convert-linalg-to-loops,convert-vector-to-scf)," f"builtin.func(linalg-bufferize,convert-linalg-to-loops,convert-vector-to-scf),"
f"convert-scf-to-std," f"convert-scf-to-cf,"
f"func-bufferize," f"func-bufferize,"
f"arith-bufferize," f"arith-bufferize,"
f"builtin.func(tensor-bufferize,finalizing-bufferize)," f"builtin.func(tensor-bufferize,finalizing-bufferize),"
f"convert-vector-to-llvm{{reassociate-fp-reductions=1 enable-index-optimizations=1}}," f"convert-vector-to-llvm{{reassociate-fp-reductions=1 enable-index-optimizations=1}},"
f"lower-affine," f"lower-affine,"
f"convert-memref-to-llvm," f"convert-memref-to-llvm,"
f"convert-std-to-llvm," f"convert-std-to-llvm,"
f"reconcile-unrealized-casts") f"reconcile-unrealized-casts")
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf \
// RUN: -memref-expand -arith-expand -convert-vector-to-llvm \ // RUN: -memref-expand -arith-expand -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm -convert-std-to-llvm \ // RUN: -convert-memref-to-llvm -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts | \ // RUN: -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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @transfer_read_2d(%A : memref<40xi32>, %base1: index) { func @transfer_read_2d(%A : memref<40xi32>, %base1: index) {
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/AMX/test-mulf-full.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf \
// RUN: -arith-bufferize -convert-vector-to-llvm="enable-amx" \ // RUN: -arith-bufferize -convert-vector-to-llvm="enable-amx" \
// RUN: -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" \
// RUN: --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AMX. // Note: To run this test, your CPU must support AMX.
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/AMX/test-mulf.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AMX. // Note: To run this test, your CPU must support AMX.
// Multiply into zeroed destination. // Multiply into zeroed destination.
func @kernel1(%arg0: memref<2x4xbf16>, func @kernel1(%arg0: memref<2x4xbf16>,
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/AMX/test-muli-ext.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AMX. // Note: To run this test, your CPU must support AMX.
func @print(%arg0: memref<16x4xi32>) { func @print(%arg0: memref<16x4xi32>) {
%iu = arith.constant -1: i32 %iu = arith.constant -1: i32
▲ Show 20 Lines • Show All 189 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/AMX/test-muli-full.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf \
// RUN: -arith-bufferize -convert-vector-to-llvm="enable-amx" \ // RUN: -arith-bufferize -convert-vector-to-llvm="enable-amx" \
// RUN: -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" \
// RUN: --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AMX. // Note: To run this test, your CPU must support AMX.
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/AMX/test-muli.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AMX. // Note: To run this test, your CPU must support AMX.
// Multiply into zeroed destination. // Multiply into zeroed destination.
func @kernel1(%arg0: memref<2x8xi8>, func @kernel1(%arg0: memref<2x8xi8>,
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/AMX/test-tilezero-block.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AMX. // Note: To run this test, your CPU must support AMX.
func @print(%arg0: memref<4x32xf32>) { func @print(%arg0: memref<4x32xf32>) {
%fu = arith.constant -1.0: f32 %fu = arith.constant -1.0: f32
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/AMX/test-tilezero.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AMX. // Note: To run this test, your CPU must support AMX.
func @tilezero(%arg0: memref<?x?xi32>, %i: index, %j: index) { func @tilezero(%arg0: memref<?x?xi32>, %i: index, %j: index) {
%1 = amx.tile_zero : vector<16x16xi32> %1 = amx.tile_zero : vector<16x16xi32>
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/X86Vector/test-dot.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm="enable-x86vector" -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm="enable-x86vector" -convert-std-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate --mlir-to-llvmir | \ // RUN: mlir-translate --mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="avx" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="avx" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() -> i32 { func @entry() -> i32 {
%i0 = arith.constant 0 : i32 %i0 = arith.constant 0 : i32
%i4 = arith.constant 4 : i32 %i4 = arith.constant 4 : i32
Show All 15 Lines

mlir/test/Integration/Dialect/Vector/CPU/X86Vector/test-inline-asm-vector-avx512.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm='use-bare-ptr-memref-call-conv=1' -convert-arith-to-llvm -reconcile-unrealized-casts |\ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm='use-bare-ptr-memref-call-conv=1' -convert-arith-to-llvm -reconcile-unrealized-casts |\
// RUN: mlir-translate --mlir-to-llvmir |\ // RUN: mlir-translate --mlir-to-llvmir |\
// RUN: %lli --entry-function=entry --mattr="avx512f" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext |\ // RUN: %lli --entry-function=entry --mattr="avx512f" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext |\
// RUN: FileCheck %s // RUN: FileCheck %s
module { module {
// an array of 16 i32 of values [0..15] // an array of 16 i32 of values [0..15]
llvm.mlir.global private @const16( llvm.mlir.global private @const16(
Show All 32 Lines

mlir/test/Integration/Dialect/Vector/CPU/X86Vector/test-mask-compress.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm="enable-x86vector" -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm="enable-x86vector" -convert-std-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate --mlir-to-llvmir | \ // RUN: mlir-translate --mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="avx512bw" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="avx512bw" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() -> i32 { func @entry() -> i32 {
%i0 = arith.constant 0 : i32 %i0 = arith.constant 0 : i32
%a = arith.constant dense<[1., 0., 0., 2., 4., 3., 5., 7., 8., 1., 5., 5., 3., 1., 0., 7.]> : vector<16xf32> %a = arith.constant dense<[1., 0., 0., 2., 4., 3., 5., 7., 8., 1., 5., 5., 3., 1., 0., 7.]> : vector<16xf32>
Show All 18 Lines

mlir/test/Integration/Dialect/Vector/CPU/X86Vector/test-sparse-dot-product.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm="enable-x86vector" -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm="enable-x86vector" -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate --mlir-to-llvmir | \ // RUN: mlir-translate --mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="avx512bw,avx512vp2intersect" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="avx512bw,avx512vp2intersect" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// This test shows how to implement a sparse vector-vector dot product with // This test shows how to implement a sparse vector-vector dot product with
// AVX512. It uses vp2intersect, mask.compress and vector.contract to compute // AVX512. It uses vp2intersect, mask.compress and vector.contract to compute
// the dot product of two sparse HW vectors of 8 float64 elements ("segment"). // the dot product of two sparse HW vectors of 8 float64 elements ("segment").
// Each sparse vector is represented by an index memref (A or C) and by a data // Each sparse vector is represented by an index memref (A or C) and by a data
▲ Show 20 Lines • Show All 468 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/X86Vector/test-vp2intersect-i32.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm="enable-x86vector" -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm="enable-x86vector" -convert-std-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate --mlir-to-llvmir | \ // RUN: mlir-translate --mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="avx512bw,avx512vp2intersect" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="avx512bw,avx512vp2intersect" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AVX512 vp2intersect. // Note: To run this test, your CPU must support AVX512 vp2intersect.
func @entry() -> i32 { func @entry() -> i32 {
%i0 = arith.constant 0 : i32 %i0 = arith.constant 0 : i32
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-0-d-vectors.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @extract_element_0d(%a: vector<f32>) { func @extract_element_0d(%a: vector<f32>) {
%1 = vector.extractelement %a[] : vector<f32> %1 = vector.extractelement %a[] : vector<f32>
// CHECK: 42 // CHECK: 42
vector.print %1: f32 vector.print %1: f32
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-broadcast.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%i = arith.constant 2147483647: i32 %i = arith.constant 2147483647: i32
%l = arith.constant 9223372036854775807 : i64 %l = arith.constant 9223372036854775807 : i64
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-compress.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @compress16(%base: memref<?xf32>, func @compress16(%base: memref<?xf32>,
%mask: vector<16xi1>, %value: vector<16xf32>) { %mask: vector<16xi1>, %value: vector<16xf32>) {
%c0 = arith.constant 0: index %c0 = arith.constant 0: index
vector.compressstore %base[%c0], %mask, %value vector.compressstore %base[%c0], %mask, %value
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-constant-mask.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%0 = vector.constant_mask [4] : vector<8xi1> %0 = vector.constant_mask [4] : vector<8xi1>
vector.print %0 : vector<8xi1> vector.print %0 : vector<8xi1>
// CHECK: ( 1, 1, 1, 1, 0, 0, 0, 0 ) // CHECK: ( 1, 1, 1, 1, 0, 0, 0, 0 )
Show All 40 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-contraction.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
#dotp_accesses = [ #dotp_accesses = [
affine_map<(i) -> (i)>, affine_map<(i) -> (i)>,
affine_map<(i) -> (i)>, affine_map<(i) -> (i)>,
affine_map<(i) -> ()> affine_map<(i) -> ()>
▲ Show 20 Lines • Show All 374 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-create-mask-v4i1.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// NOTE: This is similar to test-create-mask.mlir, but with a different length, // NOTE: This is similar to test-create-mask.mlir, but with a different length,
// because the v4i1 vector specifically exposed bugs in the LLVM backend. // because the v4i1 vector specifically exposed bugs in the LLVM backend.
func @entry() { func @entry() {
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-create-mask.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%cneg1 = arith.constant -1 : index %cneg1 = arith.constant -1 : index
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-expand.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @expand16(%base: memref<?xf32>, func @expand16(%base: memref<?xf32>,
%mask: vector<16xi1>, %mask: vector<16xi1>,
%pass_thru: vector<16xf32>) -> vector<16xf32> { %pass_thru: vector<16xf32>) -> vector<16xf32> {
%c0 = arith.constant 0: index %c0 = arith.constant 0: index
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-extract-strided-slice.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f0 = arith.constant 0.0: f32 %f0 = arith.constant 0.0: f32
%f1 = arith.constant 1.0: f32 %f1 = arith.constant 1.0: f32
%f2 = arith.constant 2.0: f32 %f2 = arith.constant 2.0: f32
Show All 23 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-flat-transpose-col.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=column-major \ // RUN: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=column-major \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f0 = arith.constant 0.0: f64 %f0 = arith.constant 0.0: f64
%f1 = arith.constant 1.0: f64 %f1 = arith.constant 1.0: f64
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-flat-transpose-row.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=row-major \ // RUN: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=row-major \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f0 = arith.constant 0.0: f64 %f0 = arith.constant 0.0: f64
%f1 = arith.constant 1.0: f64 %f1 = arith.constant 1.0: f64
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-fma.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f1 = arith.constant 1.0: f32 %f1 = arith.constant 1.0: f32
%f3 = arith.constant 3.0: f32 %f3 = arith.constant 3.0: f32
%f7 = arith.constant 7.0: f32 %f7 = arith.constant 7.0: f32
Show All 19 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-gather.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @gather8(%base: memref<?xf32>, %indices: vector<8xi32>, func @gather8(%base: memref<?xf32>, %indices: vector<8xi32>,
%mask: vector<8xi1>, %pass_thru: vector<8xf32>) -> vector<8xf32> { %mask: vector<8xi1>, %pass_thru: vector<8xf32>) -> vector<8xf32> {
%c0 = arith.constant 0: index %c0 = arith.constant 0: index
%g = vector.gather %base[%c0][%indices], %mask, %pass_thru %g = vector.gather %base[%c0][%indices], %mask, %pass_thru
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-insert-strided-slice.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f1 = arith.constant 1.0: f32 %f1 = arith.constant 1.0: f32
%f2 = arith.constant 2.0: f32 %f2 = arith.constant 2.0: f32
%f3 = arith.constant 3.0: f32 %f3 = arith.constant 3.0: f32
Show All 27 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-maskedload.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @maskedload16(%base: memref<?xf32>, %mask: vector<16xi1>, func @maskedload16(%base: memref<?xf32>, %mask: vector<16xi1>,
%pass_thru: vector<16xf32>) -> vector<16xf32> { %pass_thru: vector<16xf32>) -> vector<16xf32> {
%c0 = arith.constant 0: index %c0 = arith.constant 0: index
%ld = vector.maskedload %base[%c0], %mask, %pass_thru %ld = vector.maskedload %base[%c0], %mask, %pass_thru
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-maskedstore.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @maskedstore16(%base: memref<?xf32>, func @maskedstore16(%base: memref<?xf32>,
%mask: vector<16xi1>, %value: vector<16xf32>) { %mask: vector<16xi1>, %value: vector<16xf32>) {
%c0 = arith.constant 0: index %c0 = arith.constant 0: index
vector.maskedstore %base[%c0], %mask, %value vector.maskedstore %base[%c0], %mask, %value
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-matrix-multiply-col.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=column-major \ // RUN: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=column-major \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f0 = arith.constant 0.0: f64 %f0 = arith.constant 0.0: f64
%f1 = arith.constant 1.0: f64 %f1 = arith.constant 1.0: f64
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-matrix-multiply-row.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=row-major \ // RUN: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=row-major \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f0 = arith.constant 0.0: f64 %f0 = arith.constant 0.0: f64
%f1 = arith.constant 1.0: f64 %f1 = arith.constant 1.0: f64
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-outerproduct-f32.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
!vector_type_A = type vector<8xf32> !vector_type_A = type vector<8xf32>
!vector_type_B = type vector<8xf32> !vector_type_B = type vector<8xf32>
!vector_type_C = type vector<8x8xf32> !vector_type_C = type vector<8x8xf32>
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-outerproduct-i64.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
!vector_type_A = type vector<8xi64> !vector_type_A = type vector<8xi64>
!vector_type_B = type vector<8xi64> !vector_type_B = type vector<8xi64>
!vector_type_C = type vector<8x8xi64> !vector_type_C = type vector<8x8xi64>
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-print-int.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// //
// Test various signless, signed, unsigned integer types. // Test various signless, signed, unsigned integer types.
// //
func @entry() { func @entry() {
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-f32-reassoc.mlir

// RUN: mlir-opt %s -convert-scf-to-std \ // RUN: mlir-opt %s -convert-scf-to-cf \
// RUN: -convert-vector-to-llvm='reassociate-fp-reductions' \ // RUN: -convert-vector-to-llvm='reassociate-fp-reductions' \
// RUN: -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
// Construct test vector, numerically very stable. // Construct test vector, numerically very stable.
Show All 29 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-f32.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
// Construct test vector. // Construct test vector.
%f1 = arith.constant 1.5: f32 %f1 = arith.constant 1.5: f32
%f2 = arith.constant 2.0: f32 %f2 = arith.constant 2.0: f32
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-f64-reassoc.mlir

// RUN: mlir-opt %s -convert-scf-to-std \ // RUN: mlir-opt %s -convert-scf-to-cf \
// RUN: -convert-vector-to-llvm='reassociate-fp-reductions' \ // RUN: -convert-vector-to-llvm='reassociate-fp-reductions' \
// RUN: -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
// Construct test vector, numerically very stable. // Construct test vector, numerically very stable.
Show All 29 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-f64.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
// Construct test vector. // Construct test vector.
%f1 = arith.constant 1.5: f64 %f1 = arith.constant 1.5: f64
%f2 = arith.constant 2.0: f64 %f2 = arith.constant 2.0: f64
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-i32.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
// Construct test vector. // Construct test vector.
%i1 = arith.constant 1: i32 %i1 = arith.constant 1: i32
%i2 = arith.constant 2: i32 %i2 = arith.constant 2: i32
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-i4.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%v = arith.constant dense<[-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]> : vector<24xi4> %v = arith.constant dense<[-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]> : vector<24xi4>
vector.print %v : vector<24xi4> vector.print %v : vector<24xi4>
// //
Show All 35 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-i64.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
// Construct test vector. // Construct test vector.
%i1 = arith.constant 1: i64 %i1 = arith.constant 1: i64
%i2 = arith.constant 2: i64 %i2 = arith.constant 2: i64
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-si4.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%v0 = arith.constant dense<[-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7]> : vector<16xi4> %v0 = arith.constant dense<[-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7]> : vector<16xi4>
%v = vector.bitcast %v0 : vector<16xi4> to vector<16xsi4> %v = vector.bitcast %v0 : vector<16xi4> to vector<16xsi4>
vector.print %v : vector<16xsi4> vector.print %v : vector<16xsi4>
Show All 35 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-ui4.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%v0 = arith.constant dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]> : vector<16xi4> %v0 = arith.constant dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]> : vector<16xi4>
%v = vector.bitcast %v0 : vector<16xi4> to vector<16xui4> %v = vector.bitcast %v0 : vector<16xi4> to vector<16xui4>
vector.print %v : vector<16xui4> vector.print %v : vector<16xui4>
Show All 35 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-scan.mlir

// RUN: mlir-opt %s -test-vector-scan-lowering -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -test-vector-scan-lowering -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f1 = arith.constant 1.0: f32 %f1 = arith.constant 1.0: f32
%f2 = arith.constant 2.0: f32 %f2 = arith.constant 2.0: f32
%f3 = arith.constant 3.0: f32 %f3 = arith.constant 3.0: f32
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-scatter.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @scatter8(%base: memref<?xf32>, func @scatter8(%base: memref<?xf32>,
%indices: vector<8xi32>, %indices: vector<8xi32>,
%mask: vector<8xi1>, %value: vector<8xf32>) { %mask: vector<8xi1>, %value: vector<8xf32>) {
%c0 = arith.constant 0: index %c0 = arith.constant 0: index
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-shape-cast.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f1 = arith.constant 1.0: f32 %f1 = arith.constant 1.0: f32
%f2 = arith.constant 2.0: f32 %f2 = arith.constant 2.0: f32
%f3 = arith.constant 3.0: f32 %f3 = arith.constant 3.0: f32
Show All 35 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-shuffle.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f1 = arith.constant 1.0: f32 %f1 = arith.constant 1.0: f32
%f2 = arith.constant 2.0: f32 %f2 = arith.constant 2.0: f32
%v1 = vector.broadcast %f1 : f32 to vector<2x4xf32> %v1 = vector.broadcast %f1 : f32 to vector<2x4xf32>
Show All 15 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-sparse-dot-matvec.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Illustrates an 8x8 Sparse Matrix x Vector implemented with only operations // Illustrates an 8x8 Sparse Matrix x Vector implemented with only operations
// of the vector dialect (and some std/scf). Essentially, this example performs // of the vector dialect (and some std/scf). Essentially, this example performs
// the following multiplication: // the following multiplication:
// //
▲ Show 20 Lines • Show All 262 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-sparse-saxpy-jagged-matvec.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Illustrates an 8x8 Sparse Matrix x Vector implemented with only operations // Illustrates an 8x8 Sparse Matrix x Vector implemented with only operations
// of the vector dialect (and some std/scf). Essentially, this example performs // of the vector dialect (and some std/scf). Essentially, this example performs
// the following multiplication: // the following multiplication:
// //
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -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-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_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 204 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -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-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_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 -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -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-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @transfer_read_3d(%A : memref<?x?x?x?xf32>, 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 -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf=full-unroll=true -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf=full-unroll=true -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @transfer_read_1d(%A : memref<?xf32>, %base: index) { 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 -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf=full-unroll=true -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf=full-unroll=true -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext,%mlir_integration_test_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 private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(memref<*xf32>)
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @transfer_write16_inbounds_1d(%A : memref<?xf32>, %base: index) { func @transfer_write16_inbounds_1d(%A : memref<?xf32>, %base: index) {
%f = arith.constant 16.0 : f32 %f = arith.constant 16.0 : f32
%v = vector.splat %f : vector<16xf32> %v = vector.splat %f : vector<16xf32>
vector.transfer_write %v, %A[%base] vector.transfer_write %v, %A[%base]
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-transpose.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f0 = arith.constant 0.0: f32 %f0 = arith.constant 0.0: f32
%f1 = arith.constant 1.0: f32 %f1 = arith.constant 1.0: f32
%f2 = arith.constant 2.0: f32 %f2 = arith.constant 2.0: f32
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-vector-distribute.mlir

// RUN: mlir-opt %s -test-vector-to-forloop -convert-vector-to-scf \ // RUN: mlir-opt %s -test-vector-to-forloop -convert-vector-to-scf \
// RUN: -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine \
// RUN: -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e main \ // RUN: -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e main \
// RUN: -entry-point-result=void \ // RUN: -entry-point-result=void \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -test-vector-to-forloop | FileCheck %s -check-prefix=TRANSFORM // RUN: mlir-opt %s -test-vector-to-forloop | FileCheck %s -check-prefix=TRANSFORM
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(memref<*xf32>)
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: -gpu-kernel-outlining \ // RUN: -gpu-kernel-outlining \
// RUN: -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin{chip=sm_70})' \ // RUN: -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-nvvm,gpu-to-cubin{chip=sm_70})' \
// RUN: --convert-scf-to-std -gpu-to-llvm \ // RUN: --convert-scf-to-cf -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%linalg_test_lib_dir/libmlir_cuda_runtime%shlibext \ // RUN: --shared-libs=%linalg_test_lib_dir/libmlir_cuda_runtime%shlibext \
// RUN: --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%linalg_test_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-
// kernel-outling. // kernel-outling.
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

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

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

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

Show All 18 Linesfunc @main() {
gpu.host_register %cast_dst : memref<*xf32> gpu.host_register %cast_dst : memref<*xf32>
gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %one, %grid_y = %one, %grid_z = %one) gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %one, %grid_y = %one, %grid_z = %one)
threads(%tx, %ty, %tz) in (%block_x = %sx, %block_y = %one, %block_z = %one) { threads(%tx, %ty, %tz) in (%block_x = %sx, %block_y = %one, %block_z = %one) {
%t0 = arith.index_cast %tx : index to i32 %t0 = arith.index_cast %tx : index to i32
%val = arith.sitofp %t0 : i32 to f32 %val = arith.sitofp %t0 : i32 to f32
%width = arith.index_cast %block_x : index to i32 %width = arith.index_cast %block_x : index to i32
%offset = arith.constant 4 : i32 %offset = arith.constant 4 : i32
%shfl, %valid = gpu.shuffle xor %val, %offset, %width : f32 %shfl, %valid = gpu.shuffle xor %val, %offset, %width : f32
cond_br %valid, ^bb1(%shfl : f32), ^bb0 cf.cond_br %valid, ^bb1(%shfl : f32), ^bb0
^bb0: ^bb0:
%m1 = arith.constant -1.0 : f32 %m1 = arith.constant -1.0 : f32
br ^bb1(%m1 : f32) cf.br ^bb1(%m1 : f32)
^bb1(%value : f32): ^bb1(%value : f32):
memref.store %value, %dst[%tx] : memref<?xf32> memref.store %value, %dst[%tx] : memref<?xf32>
gpu.terminator gpu.terminator
} }
call @print_memref_f32(%cast_dst) : (memref<*xf32>) -> () call @print_memref_f32(%cast_dst) : (memref<*xf32>) -> ()
return return
} }
func private @print_memref_f32(%ptr : memref<*xf32>) func private @print_memref_f32(%ptr : memref<*xf32>)

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

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -gpu-kernel-outlining \ // RUN: -gpu-kernel-outlining \
// RUN: -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-rocdl,gpu-to-hsaco{chip=%chip})' \ // RUN: -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-rocdl,gpu-to-hsaco{chip=%chip})' \
// RUN: -gpu-to-llvm \ // RUN: -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%linalg_test_lib_dir/libmlir_rocm_runtime%shlibext \ // RUN: --shared-libs=%linalg_test_lib_dir/libmlir_rocm_runtime%shlibext \
// RUN: --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -gpu-kernel-outlining \ // RUN: -gpu-kernel-outlining \
// RUN: -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-rocdl,gpu-to-hsaco{chip=%chip})' \ // RUN: -pass-pipeline='gpu.module(strip-debuginfo,convert-gpu-to-rocdl,gpu-to-hsaco{chip=%chip})' \
// RUN: -gpu-to-llvm \ // RUN: -gpu-to-llvm \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: --shared-libs=%linalg_test_lib_dir/libmlir_rocm_runtime%shlibext \ // RUN: --shared-libs=%linalg_test_lib_dir/libmlir_rocm_runtime%shlibext \
// RUN: --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \ // RUN: --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
// RUN: --entry-point-result=void \ // RUN: --entry-point-result=void \
// RUN: | FileCheck %s // RUN: | FileCheck %s
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

mlir/test/Target/Cpp/control_flow.mlir

// RUN: mlir-translate -mlir-to-cpp -declare-variables-at-top %s | FileCheck %s -check-prefix=CPP-DECLTOP // RUN: mlir-translate -mlir-to-cpp -declare-variables-at-top %s | FileCheck %s -check-prefix=CPP-DECLTOP
// simple(10, true) -> 20 // simple(10, true) -> 20
// simple(10, false) -> 30 // simple(10, false) -> 30
func @simple(i64, i1) -> i64 { func @simple(i64, i1) -> i64 {
^bb0(%a: i64, %cond: i1): ^bb0(%a: i64, %cond: i1):
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%a: i64) cf.br ^bb3(%a: i64)
^bb2: ^bb2:
%b = emitc.call "add"(%a, %a) : (i64, i64) -> i64 %b = emitc.call "add"(%a, %a) : (i64, i64) -> i64
br ^bb3(%b: i64) cf.br ^bb3(%b: i64)
^bb3(%c: i64): ^bb3(%c: i64):
br ^bb4(%c, %a : i64, i64) cf.br ^bb4(%c, %a : i64, i64)
^bb4(%d : i64, %e : i64): ^bb4(%d : i64, %e : i64):
%0 = emitc.call "add"(%d, %e) : (i64, i64) -> i64 %0 = emitc.call "add"(%d, %e) : (i64, i64) -> i64
return %0 : i64 return %0 : i64
} }
// CPP-DECLTOP: int64_t simple(int64_t [[A:[^ ]*]], bool [[COND:[^ ]*]]) { // CPP-DECLTOP: int64_t simple(int64_t [[A:[^ ]*]], bool [[COND:[^ ]*]]) {
// CPP-DECLTOP-NEXT: int64_t [[B:[^ ]*]]; // CPP-DECLTOP-NEXT: int64_t [[B:[^ ]*]];
// CPP-DECLTOP-NEXT: int64_t [[V0:[^ ]*]]; // CPP-DECLTOP-NEXT: int64_t [[V0:[^ ]*]];
// CPP-DECLTOP-NEXT: int64_t [[C:[^ ]*]]; // CPP-DECLTOP-NEXT: int64_t [[C:[^ ]*]];
Show All 17 Lines // CPP-DECLTOP: int64_t simple(int64_t [[A:[^ ]*]], bool [[COND:[^ ]*]]) {
// CPP-DECLTOP-NEXT: goto [[BB4:[^ ]*]]; // CPP-DECLTOP-NEXT: goto [[BB4:[^ ]*]];
// CPP-DECLTOP-NEXT: [[BB4]]: // CPP-DECLTOP-NEXT: [[BB4]]:
// CPP-DECLTOP-NEXT: [[V0]] = add([[D]], [[E]]); // CPP-DECLTOP-NEXT: [[V0]] = add([[D]], [[E]]);
// CPP-DECLTOP-NEXT: return [[V0]]; // CPP-DECLTOP-NEXT: return [[V0]];
func @block_labels0() { func @block_labels0() {
^bb1: ^bb1:
br ^bb2 cf.br ^bb2
^bb2: ^bb2:
return return
} }
// CPP-DECLTOP: void block_labels0() { // CPP-DECLTOP: void block_labels0() {
// CPP-DECLTOP-NEXT: goto label2; // CPP-DECLTOP-NEXT: goto label2;
// CPP-DECLTOP-NEXT: label2: // CPP-DECLTOP-NEXT: label2:
// CPP-DECLTOP-NEXT: return; // CPP-DECLTOP-NEXT: return;
// CPP-DECLTOP-NEXT: } // CPP-DECLTOP-NEXT: }
// Repeat the same function to make sure the names of the block labels get reset. // Repeat the same function to make sure the names of the block labels get reset.
func @block_labels1() { func @block_labels1() {
^bb1: ^bb1:
br ^bb2 cf.br ^bb2
^bb2: ^bb2:
return return
} }
// CPP-DECLTOP: void block_labels1() { // CPP-DECLTOP: void block_labels1() {
// CPP-DECLTOP-NEXT: goto label2; // CPP-DECLTOP-NEXT: goto label2;
// CPP-DECLTOP-NEXT: label2: // CPP-DECLTOP-NEXT: label2:
// CPP-DECLTOP-NEXT: return; // CPP-DECLTOP-NEXT: return;
// CPP-DECLTOP-NEXT: } // CPP-DECLTOP-NEXT: }

mlir/test/Target/Cpp/invalid.mlir

// RUN: mlir-translate -split-input-file -mlir-to-cpp -verify-diagnostics %s // RUN: mlir-translate -split-input-file -mlir-to-cpp -verify-diagnostics %s
// expected-error@+1 {{'builtin.func' op with multiple blocks needs variables declared at top}} // expected-error@+1 {{'builtin.func' op with multiple blocks needs variables declared at top}}
func @multiple_blocks() { func @multiple_blocks() {
^bb1: ^bb1:
br ^bb2 cf.br ^bb2
^bb2: ^bb2:
return return
} }
// ----- // -----
func @unsupported_std_op(%arg0: f64) -> f64 { func @unsupported_std_op(%arg0: f64) -> f64 {
// expected-error@+1 {{'math.abs' op unable to find printer for op}} // expected-error@+1 {{'math.abs' op unable to find printer for op}}
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

mlir/test/Transforms/buffer-hoisting.mlir

// RUN: mlir-opt -buffer-hoisting -split-input-file %s | FileCheck %s // RUN: mlir-opt -buffer-hoisting -split-input-file %s | FileCheck %s
// This file checks the behaviour of BufferHoisting pass for moving Alloc // This file checks the behaviour of BufferHoisting pass for moving Alloc
// operations to their correct positions. // operations to their correct positions.
// Test Case: // Test Case:
// bb0 // bb0
// / \ // / \
// bb1 bb2 <- Initial position of AllocOp // bb1 bb2 <- Initial position of AllocOp
// \ / // \ /
// bb3 // bb3
// BufferHoisting expected behavior: It should move the existing AllocOp to // BufferHoisting expected behavior: It should move the existing AllocOp to
// the entry block. // the entry block.
// CHECK-LABEL: func @condBranch // CHECK-LABEL: func @condBranch
func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc() // CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc()
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// ----- // -----
// Test Case: // Test Case:
// bb0 // bb0
// / \ // / \
// bb1 bb2 <- Initial position of AllocOp // bb1 bb2 <- Initial position of AllocOp
// \ / // \ /
// bb3 // bb3
// BufferHoisting expected behavior: It should not move the existing AllocOp // BufferHoisting expected behavior: It should not move the existing AllocOp
// to any other block since the alloc has a dynamic dependency to block argument // to any other block since the alloc has a dynamic dependency to block argument
// %0 in bb2. // %0 in bb2.
// CHECK-LABEL: func @condBranchDynamicType // CHECK-LABEL: func @condBranchDynamicType
func @condBranchDynamicType( func @condBranchDynamicType(
%arg0: i1, %arg0: i1,
%arg1: memref<?xf32>, %arg1: memref<?xf32>,
%arg2: memref<?xf32>, %arg2: memref<?xf32>,
%arg3: index) { %arg3: index) {
cond_br %arg0, ^bb1, ^bb2(%arg3: index) cf.cond_br %arg0, ^bb1, ^bb2(%arg3: index)
^bb1: ^bb1:
br ^bb3(%arg1 : memref<?xf32>) cf.br ^bb3(%arg1 : memref<?xf32>)
^bb2(%0: index): ^bb2(%0: index):
%1 = memref.alloc(%0) : memref<?xf32> %1 = memref.alloc(%0) : memref<?xf32>
test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>) test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>)
br ^bb3(%1 : memref<?xf32>) cf.br ^bb3(%1 : memref<?xf32>)
^bb3(%2: memref<?xf32>): ^bb3(%2: memref<?xf32>):
test.copy(%2, %arg2) : (memref<?xf32>, memref<?xf32>) test.copy(%2, %arg2) : (memref<?xf32>, memref<?xf32>)
return return
} }
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK: ^bb2 // CHECK: ^bb2
// CHECK: ^bb2(%[[IDX:.*]]:{{.*}}) // CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc(%[[IDX]]) // CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc(%[[IDX]])
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// ----- // -----
// Test Case: // Test Case:
Show All 13 Lines
// %0 in bb2. // %0 in bb2.
// CHECK-LABEL: func @condBranchDynamicTypeNested // CHECK-LABEL: func @condBranchDynamicTypeNested
func @condBranchDynamicTypeNested( func @condBranchDynamicTypeNested(
%arg0: i1, %arg0: i1,
%arg1: memref<?xf32>, %arg1: memref<?xf32>,
%arg2: memref<?xf32>, %arg2: memref<?xf32>,
%arg3: index) { %arg3: index) {
cond_br %arg0, ^bb1, ^bb2(%arg3: index) cf.cond_br %arg0, ^bb1, ^bb2(%arg3: index)
^bb1: ^bb1:
br ^bb6(%arg1 : memref<?xf32>) cf.br ^bb6(%arg1 : memref<?xf32>)
^bb2(%0: index): ^bb2(%0: index):
%1 = memref.alloc(%0) : memref<?xf32> %1 = memref.alloc(%0) : memref<?xf32>
test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>) test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>)
cond_br %arg0, ^bb3, ^bb4 cf.cond_br %arg0, ^bb3, ^bb4
^bb3: ^bb3:
br ^bb5(%1 : memref<?xf32>) cf.br ^bb5(%1 : memref<?xf32>)
^bb4: ^bb4:
br ^bb5(%1 : memref<?xf32>) cf.br ^bb5(%1 : memref<?xf32>)
^bb5(%2: memref<?xf32>): ^bb5(%2: memref<?xf32>):
br ^bb6(%2 : memref<?xf32>) cf.br ^bb6(%2 : memref<?xf32>)
^bb6(%3: memref<?xf32>): ^bb6(%3: memref<?xf32>):
br ^bb7(%3 : memref<?xf32>) cf.br ^bb7(%3 : memref<?xf32>)
^bb7(%4: memref<?xf32>): ^bb7(%4: memref<?xf32>):
test.copy(%4, %arg2) : (memref<?xf32>, memref<?xf32>) test.copy(%4, %arg2) : (memref<?xf32>, memref<?xf32>)
return return
} }
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK: ^bb2 // CHECK: ^bb2
// CHECK: ^bb2(%[[IDX:.*]]:{{.*}}) // CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc(%[[IDX]]) // CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc(%[[IDX]])
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// ----- // -----
// Test Case: // Test Case:
// bb0 // bb0
// / \ // / \
// | bb1 <- Initial position of AllocOp // | bb1 <- Initial position of AllocOp
// \ / // \ /
// bb2 // bb2
// BufferHoisting expected behavior: It should move the existing AllocOp to // BufferHoisting expected behavior: It should move the existing AllocOp to
// the entry block. // the entry block.
// CHECK-LABEL: func @criticalEdge // CHECK-LABEL: func @criticalEdge
func @criticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @criticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>) cf.cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>)
^bb1: ^bb1:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
br ^bb2(%0 : memref<2xf32>) cf.br ^bb2(%0 : memref<2xf32>)
^bb2(%1: memref<2xf32>): ^bb2(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc() // CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc()
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// ----- // -----
// Test Case: // Test Case:
// bb0 <- Initial position of the first AllocOp // bb0 <- Initial position of the first AllocOp
// / \ // / \
// bb1 bb2 // bb1 bb2
// \ / // \ /
// bb3 <- Initial position of the second AllocOp // bb3 <- Initial position of the second AllocOp
// BufferHoisting expected behavior: It shouldn't move the AllocOps. // BufferHoisting expected behavior: It shouldn't move the AllocOps.
// CHECK-LABEL: func @ifElse // CHECK-LABEL: func @ifElse
func @ifElse(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @ifElse(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
cond_br %arg0, cf.cond_br %arg0,
^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>), ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>) ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
^bb1(%1: memref<2xf32>, %2: memref<2xf32>): ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>) cf.br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>)
^bb2(%3: memref<2xf32>, %4: memref<2xf32>): ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>) cf.br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>)
^bb3(%5: memref<2xf32>, %6: memref<2xf32>): ^bb3(%5: memref<2xf32>, %6: memref<2xf32>):
%7 = memref.alloc() : memref<2xf32> %7 = memref.alloc() : memref<2xf32>
test.buffer_based in(%7: memref<2xf32>) out(%7: memref<2xf32>) test.buffer_based in(%7: memref<2xf32>) out(%7: memref<2xf32>)
test.copy(%7, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%7, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc() // CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// CHECK: br ^bb3 // CHECK: cf.br ^bb3
// CHECK: br ^bb3 // CHECK: cf.br ^bb3
// CHECK-NEXT: ^bb3 // CHECK-NEXT: ^bb3
// CHECK: %[[ALLOC1:.*]] = memref.alloc() // CHECK: %[[ALLOC1:.*]] = memref.alloc()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// CHECK: test.copy(%[[ALLOC1]] // CHECK: test.copy(%[[ALLOC1]]
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// Test Case: No users for buffer in if-else CFG // Test Case: No users for buffer in if-else CFG
// bb0 <- Initial position of AllocOp // bb0 <- Initial position of AllocOp
// / \ // / \
// bb1 bb2 // bb1 bb2
// \ / // \ /
// bb3 // bb3
// BufferHoisting expected behavior: It shouldn't move the AllocOp. // BufferHoisting expected behavior: It shouldn't move the AllocOp.
// CHECK-LABEL: func @ifElseNoUsers // CHECK-LABEL: func @ifElseNoUsers
func @ifElseNoUsers(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @ifElseNoUsers(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
cond_br %arg0, cf.cond_br %arg0,
^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>), ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>) ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
^bb1(%1: memref<2xf32>, %2: memref<2xf32>): ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>) cf.br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>)
^bb2(%3: memref<2xf32>, %4: memref<2xf32>): ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>) cf.br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>)
^bb3(%5: memref<2xf32>, %6: memref<2xf32>): ^bb3(%5: memref<2xf32>, %6: memref<2xf32>):
test.copy(%arg1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%arg1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc() // CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
Show All 9 Lines
// \ / // \ /
// bb5 <- Initial position of the second AllocOp // bb5 <- Initial position of the second AllocOp
// BufferHoisting expected behavior: AllocOps shouldn't be moved. // BufferHoisting expected behavior: AllocOps shouldn't be moved.
// CHECK-LABEL: func @ifElseNested // CHECK-LABEL: func @ifElseNested
func @ifElseNested(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @ifElseNested(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
cond_br %arg0, cf.cond_br %arg0,
^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>), ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>) ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
^bb1(%1: memref<2xf32>, %2: memref<2xf32>): ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>) cf.br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>)
^bb2(%3: memref<2xf32>, %4: memref<2xf32>): ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>) cf.cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>)
^bb3(%5: memref<2xf32>): ^bb3(%5: memref<2xf32>):
br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>) cf.br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>)
^bb4(%6: memref<2xf32>): ^bb4(%6: memref<2xf32>):
br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>) cf.br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>)
^bb5(%7: memref<2xf32>, %8: memref<2xf32>): ^bb5(%7: memref<2xf32>, %8: memref<2xf32>):
%9 = memref.alloc() : memref<2xf32> %9 = memref.alloc() : memref<2xf32>
test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>) test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>)
test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc() // CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// CHECK: br ^bb5 // CHECK: cf.br ^bb5
// CHECK: br ^bb5 // CHECK: cf.br ^bb5
// CHECK: br ^bb5 // CHECK: cf.br ^bb5
// CHECK-NEXT: ^bb5 // CHECK-NEXT: ^bb5
// CHECK: %[[ALLOC1:.*]] = memref.alloc() // CHECK: %[[ALLOC1:.*]] = memref.alloc()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// ----- // -----
// Test Case: Dead operations in a single block. // Test Case: Dead operations in a single block.
// BufferHoisting expected behavior: It shouldn't move the AllocOps. // BufferHoisting expected behavior: It shouldn't move the AllocOps.
Show All 23 Lines
// BufferHoisting expected behavior: Both AllocOps should be moved to the // BufferHoisting expected behavior: Both AllocOps should be moved to the
// entry block. // entry block.
// CHECK-LABEL: func @moving_alloc_and_inserting_missing_dealloc // CHECK-LABEL: func @moving_alloc_and_inserting_missing_dealloc
func @moving_alloc_and_inserting_missing_dealloc( func @moving_alloc_and_inserting_missing_dealloc(
%cond: i1, %cond: i1,
%arg0: memref<2xf32>, %arg0: memref<2xf32>,
%arg1: memref<2xf32>) { %arg1: memref<2xf32>) {
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>)
br ^exit(%0 : memref<2xf32>) cf.br ^exit(%0 : memref<2xf32>)
^bb2: ^bb2:
%1 = memref.alloc() : memref<2xf32> %1 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>) test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>)
br ^exit(%1 : memref<2xf32>) cf.br ^exit(%1 : memref<2xf32>)
^exit(%arg2: memref<2xf32>): ^exit(%arg2: memref<2xf32>):
test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>) test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %{{.*}} = memref.alloc() // CHECK-NEXT: %{{.*}} = memref.alloc()
// CHECK-NEXT: %{{.*}} = memref.alloc() // CHECK-NEXT: %{{.*}} = memref.alloc()
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// ----- // -----
// Test Case: Invalid position of the DeallocOp. There is a user after // Test Case: Invalid position of the DeallocOp. There is a user after
// deallocation. // deallocation.
// bb0 // bb0
// / \ // / \
// bb1 bb2 <- Initial position of AllocOp // bb1 bb2 <- Initial position of AllocOp
// \ / // \ /
// bb3 // bb3
// BufferHoisting expected behavior: It should move the AllocOp to the entry // BufferHoisting expected behavior: It should move the AllocOp to the entry
// block. // block.
// CHECK-LABEL: func @moving_invalid_dealloc_op_complex // CHECK-LABEL: func @moving_invalid_dealloc_op_complex
func @moving_invalid_dealloc_op_complex( func @moving_invalid_dealloc_op_complex(
%cond: i1, %cond: i1,
%arg0: memref<2xf32>, %arg0: memref<2xf32>,
%arg1: memref<2xf32>) { %arg1: memref<2xf32>) {
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
br ^exit(%arg0 : memref<2xf32>) cf.br ^exit(%arg0 : memref<2xf32>)
^bb2: ^bb2:
%1 = memref.alloc() : memref<2xf32> %1 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>) test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>)
memref.dealloc %1 : memref<2xf32> memref.dealloc %1 : memref<2xf32>
br ^exit(%1 : memref<2xf32>) cf.br ^exit(%1 : memref<2xf32>)
^exit(%arg2: memref<2xf32>): ^exit(%arg2: memref<2xf32>):
test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>) test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %{{.*}} = memref.alloc() // CHECK-NEXT: %{{.*}} = memref.alloc()
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// ----- // -----
// Test Case: Nested regions - This test defines a BufferBasedOp inside the // Test Case: Nested regions - This test defines a BufferBasedOp inside the
// region of a RegionBufferBasedOp. // region of a RegionBufferBasedOp.
// BufferHoisting expected behavior: The AllocOp for the BufferBasedOp should // BufferHoisting expected behavior: The AllocOp for the BufferBasedOp should
// remain inside the region of the RegiobBufferBasedOp. The AllocOp of the // remain inside the region of the RegiobBufferBasedOp. The AllocOp of the
// RegionBufferBasedOp should be moved to the entry block. // RegionBufferBasedOp should be moved to the entry block.
// CHECK-LABEL: func @nested_regions_and_cond_branch // CHECK-LABEL: func @nested_regions_and_cond_branch
func @nested_regions_and_cond_branch( func @nested_regions_and_cond_branch(
%arg0: i1, %arg0: i1,
%arg1: memref<2xf32>, %arg1: memref<2xf32>,
%arg2: memref<2xf32>) { %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) { test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) {
^bb0(%gen1_arg0: f32, %gen1_arg1: f32): ^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
%1 = memref.alloc() : memref<2xf32> %1 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>)
%tmp1 = math.exp %gen1_arg0 : f32 %tmp1 = math.exp %gen1_arg0 : f32
test.region_yield %tmp1 : f32 test.region_yield %tmp1 : f32
} }
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc() // CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK: test.region_buffer_based // CHECK: test.region_buffer_based
// CHECK: %[[ALLOC1:.*]] = memref.alloc() // CHECK: %[[ALLOC1:.*]] = memref.alloc()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// ----- // -----
// Test Case: nested region control flow // Test Case: nested region control flow
// The alloc position of %1 does not need to be changed and flows through // The alloc position of %1 does not need to be changed and flows through
▲ Show 20 Lines • Show All 170 Lines • ▼ Show 20 Lines
// CHECK-NEXT: {{.*}} test.region_if // CHECK-NEXT: {{.*}} test.region_if
// ----- // -----
// Test Case: Alloca operations shouldn't be moved. // Test Case: Alloca operations shouldn't be moved.
// CHECK-LABEL: func @condBranchAlloca // CHECK-LABEL: func @condBranchAlloca
func @condBranchAlloca(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @condBranchAlloca(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloca() : memref<2xf32> %0 = memref.alloca() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK: ^bb2 // CHECK: ^bb2
// CHECK: ^bb2 // CHECK: ^bb2
// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca() // CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// ----- // -----
// Test Case: Alloca operations shouldn't be moved. The alloc operation also // Test Case: Alloca operations shouldn't be moved. The alloc operation also
// shouldn't be moved analogously to the ifElseNested test. // shouldn't be moved analogously to the ifElseNested test.
// CHECK-LABEL: func @ifElseNestedAlloca // CHECK-LABEL: func @ifElseNestedAlloca
func @ifElseNestedAlloca( func @ifElseNestedAlloca(
%arg0: i1, %arg0: i1,
%arg1: memref<2xf32>, %arg1: memref<2xf32>,
%arg2: memref<2xf32>) { %arg2: memref<2xf32>) {
%0 = memref.alloca() : memref<2xf32> %0 = memref.alloca() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
cond_br %arg0, cf.cond_br %arg0,
^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>), ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>) ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
^bb1(%1: memref<2xf32>, %2: memref<2xf32>): ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>) cf.br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>)
^bb2(%3: memref<2xf32>, %4: memref<2xf32>): ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>) cf.cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>)
^bb3(%5: memref<2xf32>): ^bb3(%5: memref<2xf32>):
br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>) cf.br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>)
^bb4(%6: memref<2xf32>): ^bb4(%6: memref<2xf32>):
br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>) cf.br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>)
^bb5(%7: memref<2xf32>, %8: memref<2xf32>): ^bb5(%7: memref<2xf32>, %8: memref<2xf32>):
%9 = memref.alloc() : memref<2xf32> %9 = memref.alloc() : memref<2xf32>
test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>) test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>)
test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca() // CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
Show All 10 Lines
// Test Case: Alloca operations shouldn't be moved. The alloc operation should // Test Case: Alloca operations shouldn't be moved. The alloc operation should
// be moved in the beginning analogous to the nestedRegionsAndCondBranch test. // be moved in the beginning analogous to the nestedRegionsAndCondBranch test.
// CHECK-LABEL: func @nestedRegionsAndCondBranchAlloca // CHECK-LABEL: func @nestedRegionsAndCondBranchAlloca
func @nestedRegionsAndCondBranchAlloca( func @nestedRegionsAndCondBranchAlloca(
%arg0: i1, %arg0: i1,
%arg1: memref<2xf32>, %arg1: memref<2xf32>,
%arg2: memref<2xf32>) { %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) { test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) {
^bb0(%gen1_arg0: f32, %gen1_arg1: f32): ^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
%1 = memref.alloca() : memref<2xf32> %1 = memref.alloca() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>)
%tmp1 = math.exp %gen1_arg0 : f32 %tmp1 = math.exp %gen1_arg0 : f32
test.region_yield %tmp1 : f32 test.region_yield %tmp1 : f32
} }
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc() // CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc()
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK: test.region_buffer_based // CHECK: test.region_buffer_based
// CHECK: %[[ALLOCA:.*]] = memref.alloca() // CHECK: %[[ALLOCA:.*]] = memref.alloca()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// ----- // -----
// Test Case: structured control-flow loop using a nested alloc. // Test Case: structured control-flow loop using a nested alloc.
// The alloc positions of %3 will be moved upwards. // The alloc positions of %3 will be moved upwards.
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

mlir/test/Transforms/buffer-loop-hoisting.mlir

// RUN: mlir-opt -buffer-loop-hoisting -split-input-file %s | FileCheck %s // RUN: mlir-opt -buffer-loop-hoisting -split-input-file %s | FileCheck %s
// This file checks the behavior of BufferLoopHoisting pass for moving Alloc // This file checks the behavior of BufferLoopHoisting pass for moving Alloc
// operations in their correct positions. // operations in their correct positions.
// Test Case: // Test Case:
// bb0 // bb0
// / \ // / \
// bb1 bb2 <- Initial position of AllocOp // bb1 bb2 <- Initial position of AllocOp
// \ / // \ /
// bb3 // bb3
// BufferLoopHoisting expected behavior: It should not move the AllocOp. // BufferLoopHoisting expected behavior: It should not move the AllocOp.
// CHECK-LABEL: func @condBranch // CHECK-LABEL: func @condBranch
func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK: %[[ALLOC:.*]] = memref.alloc() // CHECK: %[[ALLOC:.*]] = memref.alloc()
// ----- // -----
// Test Case: // Test Case:
// bb0 // bb0
// / \ // / \
// bb1 bb2 <- Initial position of AllocOp // bb1 bb2 <- Initial position of AllocOp
// \ / // \ /
// bb3 // bb3
// BufferLoopHoisting expected behavior: It should not move the existing AllocOp // BufferLoopHoisting expected behavior: It should not move the existing AllocOp
// to any other block since the alloc has a dynamic dependency to block argument // to any other block since the alloc has a dynamic dependency to block argument
// %0 in bb2. // %0 in bb2.
// CHECK-LABEL: func @condBranchDynamicType // CHECK-LABEL: func @condBranchDynamicType
func @condBranchDynamicType( func @condBranchDynamicType(
%arg0: i1, %arg0: i1,
%arg1: memref<?xf32>, %arg1: memref<?xf32>,
%arg2: memref<?xf32>, %arg2: memref<?xf32>,
%arg3: index) { %arg3: index) {
cond_br %arg0, ^bb1, ^bb2(%arg3: index) cf.cond_br %arg0, ^bb1, ^bb2(%arg3: index)
^bb1: ^bb1:
br ^bb3(%arg1 : memref<?xf32>) cf.br ^bb3(%arg1 : memref<?xf32>)
^bb2(%0: index): ^bb2(%0: index):
%1 = memref.alloc(%0) : memref<?xf32> %1 = memref.alloc(%0) : memref<?xf32>
test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>) test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>)
br ^bb3(%1 : memref<?xf32>) cf.br ^bb3(%1 : memref<?xf32>)
^bb3(%2: memref<?xf32>): ^bb3(%2: memref<?xf32>):
test.copy(%2, %arg2) : (memref<?xf32>, memref<?xf32>) test.copy(%2, %arg2) : (memref<?xf32>, memref<?xf32>)
return return
} }
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK: ^bb2 // CHECK: ^bb2
// CHECK: ^bb2(%[[IDX:.*]]:{{.*}}) // CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc(%[[IDX]]) // CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc(%[[IDX]])
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// ----- // -----
// Test Case: Nested regions - This test defines a BufferBasedOp inside the // Test Case: Nested regions - This test defines a BufferBasedOp inside the
// region of a RegionBufferBasedOp. // region of a RegionBufferBasedOp.
// BufferLoopHoisting expected behavior: The AllocOp for the BufferBasedOp // BufferLoopHoisting expected behavior: The AllocOp for the BufferBasedOp
// should remain inside the region of the RegionBufferBasedOp. The AllocOp of // should remain inside the region of the RegionBufferBasedOp. The AllocOp of
// the RegionBufferBasedOp should not be moved during this pass. // the RegionBufferBasedOp should not be moved during this pass.
// CHECK-LABEL: func @nested_regions_and_cond_branch // CHECK-LABEL: func @nested_regions_and_cond_branch
func @nested_regions_and_cond_branch( func @nested_regions_and_cond_branch(
%arg0: i1, %arg0: i1,
%arg1: memref<2xf32>, %arg1: memref<2xf32>,
%arg2: memref<2xf32>) { %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) { test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) {
^bb0(%gen1_arg0: f32, %gen1_arg1: f32): ^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
%1 = memref.alloc() : memref<2xf32> %1 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>)
%tmp1 = math.exp %gen1_arg0 : f32 %tmp1 = math.exp %gen1_arg0 : f32
test.region_yield %tmp1 : f32 test.region_yield %tmp1 : f32
} }
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK: %[[ALLOC0:.*]] = memref.alloc() // CHECK: %[[ALLOC0:.*]] = memref.alloc()
// CHECK: test.region_buffer_based // CHECK: test.region_buffer_based
// CHECK: %[[ALLOC1:.*]] = memref.alloc() // CHECK: %[[ALLOC1:.*]] = memref.alloc()
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// ----- // -----
// Test Case: nested region control flow // Test Case: nested region control flow
▲ Show 20 Lines • Show All 384 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
// update th predecessor. // update th predecessor.
// CHECK-LABEL: func @mismatch_operands // CHECK-LABEL: func @mismatch_operands
// CHECK-SAME: %[[COND:.*]]: i1, %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32 // CHECK-SAME: %[[COND:.*]]: i1, %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32
func @mismatch_operands(%cond : i1, %arg0 : i32, %arg1 : i32) -> i32 { func @mismatch_operands(%cond : i1, %arg0 : i32, %arg1 : i32) -> i32 {
// CHECK: %[[RES:.*]] = arith.select %[[COND]], %[[ARG0]], %[[ARG1]] // CHECK: %[[RES:.*]] = arith.select %[[COND]], %[[ARG0]], %[[ARG1]]
// CHECK: return %[[RES]] // CHECK: return %[[RES]]
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
return %arg0 : i32 return %arg0 : i32
^bb2: ^bb2:
return %arg1 : i32 return %arg1 : i32
} }
// Check the same as above, but with pre-existing arguments. // Check the same as above, but with pre-existing arguments.
// CHECK-LABEL: func @mismatch_operands_matching_arguments( // CHECK-LABEL: func @mismatch_operands_matching_arguments(
// CHECK-SAME: %[[COND:.*]]: i1, %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32 // CHECK-SAME: %[[COND:.*]]: i1, %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32
func @mismatch_operands_matching_arguments(%cond : i1, %arg0 : i32, %arg1 : i32) -> (i32, i32) { func @mismatch_operands_matching_arguments(%cond : i1, %arg0 : i32, %arg1 : i32) -> (i32, i32) {
// CHECK: %[[RES0:.*]] = arith.select %[[COND]], %[[ARG1]], %[[ARG0]] // CHECK: %[[RES0:.*]] = arith.select %[[COND]], %[[ARG1]], %[[ARG0]]
// CHECK: %[[RES1:.*]] = arith.select %[[COND]], %[[ARG0]], %[[ARG1]] // CHECK: %[[RES1:.*]] = arith.select %[[COND]], %[[ARG0]], %[[ARG1]]
// CHECK: return %[[RES1]], %[[RES0]] // CHECK: return %[[RES1]], %[[RES0]]
cond_br %cond, ^bb1(%arg1 : i32), ^bb2(%arg0 : i32) cf.cond_br %cond, ^bb1(%arg1 : i32), ^bb2(%arg0 : i32)
^bb1(%arg2 : i32): ^bb1(%arg2 : i32):
return %arg0, %arg2 : i32, i32 return %arg0, %arg2 : i32, i32
^bb2(%arg3 : i32): ^bb2(%arg3 : i32):
return %arg1, %arg3 : i32, i32 return %arg1, %arg3 : i32, i32
} }
// Check that merging does not occur if the uses of the arguments differ. // Check that merging does not occur if the uses of the arguments differ.
// CHECK-LABEL: func @mismatch_argument_uses( // CHECK-LABEL: func @mismatch_argument_uses(
func @mismatch_argument_uses(%cond : i1, %arg0 : i32, %arg1 : i32) -> (i32, i32) { func @mismatch_argument_uses(%cond : i1, %arg0 : i32, %arg1 : i32) -> (i32, i32) {
// CHECK: cond_br %{{.*}}, ^bb1(%{{.*}}), ^bb2 // CHECK: cf.cond_br %{{.*}}, ^bb1(%{{.*}}), ^bb2
cond_br %cond, ^bb1(%arg1 : i32), ^bb2(%arg0 : i32) cf.cond_br %cond, ^bb1(%arg1 : i32), ^bb2(%arg0 : i32)
^bb1(%arg2 : i32): ^bb1(%arg2 : i32):
return %arg0, %arg2 : i32, i32 return %arg0, %arg2 : i32, i32
^bb2(%arg3 : i32): ^bb2(%arg3 : i32):
return %arg3, %arg1 : i32, i32 return %arg3, %arg1 : i32, i32
} }
// Check that merging does not occur if the types of the arguments differ. // Check that merging does not occur if the types of the arguments differ.
// CHECK-LABEL: func @mismatch_argument_types( // CHECK-LABEL: func @mismatch_argument_types(
func @mismatch_argument_types(%cond : i1, %arg0 : i32, %arg1 : i16) { func @mismatch_argument_types(%cond : i1, %arg0 : i32, %arg1 : i16) {
// CHECK: cond_br %{{.*}}, ^bb1(%{{.*}}), ^bb2 // CHECK: cf.cond_br %{{.*}}, ^bb1(%{{.*}}), ^bb2
cond_br %cond, ^bb1(%arg0 : i32), ^bb2(%arg1 : i16) cf.cond_br %cond, ^bb1(%arg0 : i32), ^bb2(%arg1 : i16)
^bb1(%arg2 : i32): ^bb1(%arg2 : i32):
"foo.return"(%arg2) : (i32) -> () "foo.return"(%arg2) : (i32) -> ()
^bb2(%arg3 : i16): ^bb2(%arg3 : i16):
"foo.return"(%arg3) : (i16) -> () "foo.return"(%arg3) : (i16) -> ()
} }
// Check that merging does not occur if the number of the arguments differ. // Check that merging does not occur if the number of the arguments differ.
// CHECK-LABEL: func @mismatch_argument_count( // CHECK-LABEL: func @mismatch_argument_count(
func @mismatch_argument_count(%cond : i1, %arg0 : i32) { func @mismatch_argument_count(%cond : i1, %arg0 : i32) {
// CHECK: cond_br %{{.*}}, ^bb1(%{{.*}}), ^bb2 // CHECK: cf.cond_br %{{.*}}, ^bb1(%{{.*}}), ^bb2
cond_br %cond, ^bb1(%arg0 : i32), ^bb2 cf.cond_br %cond, ^bb1(%arg0 : i32), ^bb2
^bb1(%arg2 : i32): ^bb1(%arg2 : i32):
"foo.return"(%arg2) : (i32) -> () "foo.return"(%arg2) : (i32) -> ()
^bb2: ^bb2:
"foo.return"() : () -> () "foo.return"() : () -> ()
} }
// Check that merging does not occur if the operations differ. // Check that merging does not occur if the operations differ.
// CHECK-LABEL: func @mismatch_operations( // CHECK-LABEL: func @mismatch_operations(
func @mismatch_operations(%cond : i1) { func @mismatch_operations(%cond : i1) {
// CHECK: cond_br %{{.*}}, ^bb1, ^bb2 // CHECK: cf.cond_br %{{.*}}, ^bb1, ^bb2
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
"foo.return"() : () -> () "foo.return"() : () -> ()
^bb2: ^bb2:
return return
} }
// Check that merging does not occur if the number of operations differ. // Check that merging does not occur if the number of operations differ.
// CHECK-LABEL: func @mismatch_operation_count( // CHECK-LABEL: func @mismatch_operation_count(
func @mismatch_operation_count(%cond : i1) { func @mismatch_operation_count(%cond : i1) {
// CHECK: cond_br %{{.*}}, ^bb1, ^bb2 // CHECK: cf.cond_br %{{.*}}, ^bb1, ^bb2
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
"foo.op"() : () -> () "foo.op"() : () -> ()
return return
^bb2: ^bb2:
return return
} }
// Check that merging does not occur if the blocks contain regions. // Check that merging does not occur if the blocks contain regions.
// CHECK-LABEL: func @contains_regions( // CHECK-LABEL: func @contains_regions(
func @contains_regions(%cond : i1) { func @contains_regions(%cond : i1) {
// CHECK: cond_br %{{.*}}, ^bb1, ^bb2 // CHECK: cf.cond_br %{{.*}}, ^bb1, ^bb2
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
scf.if %cond { scf.if %cond {
"foo.op"() : () -> () "foo.op"() : () -> ()
} }
return return
^bb2: ^bb2:
scf.if %cond { scf.if %cond {
"foo.op"() : () -> () "foo.op"() : () -> ()
} }
return return
} }
// Check that properly handles back edges. // Check that properly handles back edges.
// CHECK-LABEL: func @mismatch_loop( // CHECK-LABEL: func @mismatch_loop(
// CHECK-SAME: %[[ARG:.*]]: i1, %[[ARG2:.*]]: i1 // CHECK-SAME: %[[ARG:.*]]: i1, %[[ARG2:.*]]: i1
func @mismatch_loop(%cond : i1, %cond2 : i1) { func @mismatch_loop(%cond : i1, %cond2 : i1) {
// CHECK-NEXT: %[[LOOP_CARRY:.*]] = "foo.op" // CHECK-NEXT: %[[LOOP_CARRY:.*]] = "foo.op"
// CHECK: cond_br %{{.*}}, ^bb1(%[[ARG2]] : i1), ^bb2 // CHECK: cf.cond_br %{{.*}}, ^bb1(%[[ARG2]] : i1), ^bb2
%cond3 = "foo.op"() : () -> (i1) %cond3 = "foo.op"() : () -> (i1)
cond_br %cond, ^bb2, ^bb3 cf.cond_br %cond, ^bb2, ^bb3
^bb1: ^bb1:
// CHECK: ^bb1(%[[ARG3:.*]]: i1): // CHECK: ^bb1(%[[ARG3:.*]]: i1):
// CHECK-NEXT: cond_br %[[ARG3]], ^bb1(%[[LOOP_CARRY]] : i1), ^bb2 // CHECK-NEXT: cf.cond_br %[[ARG3]], ^bb1(%[[LOOP_CARRY]] : i1), ^bb2
cond_br %cond3, ^bb1, ^bb3 cf.cond_br %cond3, ^bb1, ^bb3
^bb2: ^bb2:
cond_br %cond2, ^bb1, ^bb3 cf.cond_br %cond2, ^bb1, ^bb3
^bb3: ^bb3:
// CHECK: ^bb2: // CHECK: ^bb2:
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// Check that blocks are not merged if the types of the operands differ. // Check that blocks are not merged if the types of the operands differ.
// CHECK-LABEL: func @mismatch_operand_types( // CHECK-LABEL: func @mismatch_operand_types(
func @mismatch_operand_types(%arg0 : i1, %arg1 : memref<i32>, %arg2 : memref<i1>) { func @mismatch_operand_types(%arg0 : i1, %arg1 : memref<i32>, %arg2 : memref<i1>) {
%c0_i32 = arith.constant 0 : i32 %c0_i32 = arith.constant 0 : i32
%true = arith.constant true %true = arith.constant true
br ^bb1 cf.br ^bb1
^bb1: ^bb1:
cond_br %arg0, ^bb2, ^bb3 cf.cond_br %arg0, ^bb2, ^bb3
^bb2: ^bb2:
// CHECK: memref.store %{{.*}}, %{{.*}} : memref<i32> // CHECK: memref.store %{{.*}}, %{{.*}} : memref<i32>
memref.store %c0_i32, %arg1[] : memref<i32> memref.store %c0_i32, %arg1[] : memref<i32>
br ^bb1 cf.br ^bb1
^bb3: ^bb3:
// CHECK: memref.store %{{.*}}, %{{.*}} : memref<i1> // CHECK: memref.store %{{.*}}, %{{.*}} : memref<i1>
memref.store %true, %arg2[] : memref<i1> memref.store %true, %arg2[] : memref<i1>
br ^bb1 cf.br ^bb1
} }
// Check that it is illegal to merge blocks containing an operand // Check that it is illegal to merge blocks containing an operand
// with an external user. Incorrectly performing the optimization // with an external user. Incorrectly performing the optimization
// anyways will result in print(merged, merged) rather than // anyways will result in print(merged, merged) rather than
// distinct operands. // distinct operands.
func private @print(%arg0: i32, %arg1: i32) func private @print(%arg0: i32, %arg1: i32)
// CHECK-LABEL: @nomerge // CHECK-LABEL: @nomerge
func @nomerge(%arg0: i32, %i: i32) { func @nomerge(%arg0: i32, %i: i32) {
%c1_i32 = arith.constant 1 : i32 %c1_i32 = arith.constant 1 : i32
%icmp = arith.cmpi slt, %i, %arg0 : i32 %icmp = arith.cmpi slt, %i, %arg0 : i32
cond_br %icmp, ^bb2, ^bb3 cf.cond_br %icmp, ^bb2, ^bb3
^bb2: // pred: ^bb1 ^bb2: // pred: ^bb1
%ip1 = arith.addi %i, %c1_i32 : i32 %ip1 = arith.addi %i, %c1_i32 : i32
br ^bb4(%ip1 : i32) cf.br ^bb4(%ip1 : i32)
^bb7: // pred: ^bb5 ^bb7: // pred: ^bb5
%jp1 = arith.addi %j, %c1_i32 : i32 %jp1 = arith.addi %j, %c1_i32 : i32
br ^bb4(%jp1 : i32) cf.br ^bb4(%jp1 : i32)
^bb4(%j: i32): // 2 preds: ^bb2, ^bb7 ^bb4(%j: i32): // 2 preds: ^bb2, ^bb7
%jcmp = arith.cmpi slt, %j, %arg0 : i32 %jcmp = arith.cmpi slt, %j, %arg0 : i32
// CHECK-NOT: call @print(%[[arg1:.+]], %[[arg1]]) // CHECK-NOT: call @print(%[[arg1:.+]], %[[arg1]])
call @print(%j, %ip1) : (i32, i32) -> () call @print(%j, %ip1) : (i32, i32) -> ()
cond_br %jcmp, ^bb7, ^bb3 cf.cond_br %jcmp, ^bb7, ^bb3
^bb3: // pred: ^bb1 ^bb3: // pred: ^bb1
return return
} }

mlir/test/Transforms/canonicalize-dce.mlir

Show All 24 Lines^succ(%0: f32):
return return
} }
// ----- // -----
// Test case: Deleting recursively dead block arguments. // Test case: Deleting recursively dead block arguments.
// CHECK: func @f(%arg0: f32) // CHECK: func @f(%arg0: f32)
// CHECK-NEXT: br ^bb1 // CHECK-NEXT: cf.br ^bb1
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
// CHECK-NEXT: br ^bb1 // CHECK-NEXT: cf.br ^bb1
func @f(%arg0: f32) { func @f(%arg0: f32) {
br ^loop(%arg0: f32) cf.br ^loop(%arg0: f32)
^loop(%loop: f32): ^loop(%loop: f32):
br ^loop(%loop: f32) cf.br ^loop(%loop: f32)
} }
// ----- // -----
// Test case: Deleting recursively dead block arguments with pure ops in between. // Test case: Deleting recursively dead block arguments with pure ops in between.
// CHECK: func @f(%arg0: f32) // CHECK: func @f(%arg0: f32)
// CHECK-NEXT: br ^bb1 // CHECK-NEXT: cf.br ^bb1
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
// CHECK-NEXT: br ^bb1 // CHECK-NEXT: cf.br ^bb1
func @f(%arg0: f32) { func @f(%arg0: f32) {
br ^loop(%arg0: f32) cf.br ^loop(%arg0: f32)
^loop(%0: f32): ^loop(%0: f32):
%1 = "math.exp"(%0) : (f32) -> f32 %1 = "math.exp"(%0) : (f32) -> f32
br ^loop(%1: f32) cf.br ^loop(%1: f32)
} }
// ----- // -----
// Test case: Delete block arguments for cond_br. // Test case: Delete block arguments for cf.cond_br.
// CHECK: func @f(%arg0: f32, %arg1: i1) // CHECK: func @f(%arg0: f32, %arg1: i1)
// CHECK-NEXT: return // CHECK-NEXT: return
func @f(%arg0: f32, %pred: i1) { func @f(%arg0: f32, %pred: i1) {
%exp = "math.exp"(%arg0) : (f32) -> f32 %exp = "math.exp"(%arg0) : (f32) -> f32
cond_br %pred, ^true(%exp: f32), ^false(%exp: f32) cf.cond_br %pred, ^true(%exp: f32), ^false(%exp: f32)
^true(%0: f32): ^true(%0: f32):
return return
^false(%1: f32): ^false(%1: f32):
return return
} }
// ----- // -----
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

mlir/test/Transforms/canonicalize.mlir

Show First 20 Lines • Show All 383 Lines • ▼ Show 20 Linesfunc @dead_dealloc_fold() {
memref.dealloc %a: memref<4xf32> memref.dealloc %a: memref<4xf32>
return return
} }
// CHECK-LABEL: func @dead_dealloc_fold_multi_use // CHECK-LABEL: func @dead_dealloc_fold_multi_use
func @dead_dealloc_fold_multi_use(%cond : i1) { func @dead_dealloc_fold_multi_use(%cond : i1) {
// CHECK-NEXT: return // CHECK-NEXT: return
%a = memref.alloc() : memref<4xf32> %a = memref.alloc() : memref<4xf32>
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
memref.dealloc %a: memref<4xf32> memref.dealloc %a: memref<4xf32>
return return
^bb2: ^bb2:
memref.dealloc %a: memref<4xf32> memref.dealloc %a: memref<4xf32>
return return
▲ Show 20 Lines • Show All 851 Lines • Show Last 20 Lines

mlir/test/Transforms/control-flow-sink.mlir

Show First 20 Lines • Show All 111 Lines • ▼ Show 20 Lines
// Test that ops can be sunk into regions with multiple blocks. // Test that ops can be sunk into regions with multiple blocks.
// CHECK-LABEL: @test_multiblock_region_sink // CHECK-LABEL: @test_multiblock_region_sink
// CHECK-SAME: (%[[ARG0:.*]]: i1, %[[ARG1:.*]]: i32, %[[ARG2:.*]]: i32) // CHECK-SAME: (%[[ARG0:.*]]: i1, %[[ARG1:.*]]: i32, %[[ARG2:.*]]: i32)
// CHECK-NEXT: %[[V0:.*]] = arith.addi %[[ARG1]], %[[ARG2]] // CHECK-NEXT: %[[V0:.*]] = arith.addi %[[ARG1]], %[[ARG2]]
// CHECK-NEXT: %[[V1:.*]] = "test.any_cond"() ({ // CHECK-NEXT: %[[V1:.*]] = "test.any_cond"() ({
// CHECK-NEXT: %[[V3:.*]] = arith.addi %[[V0]], %[[ARG2]] // CHECK-NEXT: %[[V3:.*]] = arith.addi %[[V0]], %[[ARG2]]
// CHECK-NEXT: %[[V4:.*]] = arith.addi %[[V3]], %[[ARG1]] // CHECK-NEXT: %[[V4:.*]] = arith.addi %[[V3]], %[[ARG1]]
// CHECK-NEXT: br ^bb1(%[[V4]] : i32) // CHECK-NEXT: cf.br ^bb1(%[[V4]] : i32)
// CHECK-NEXT: ^bb1(%[[V5:.*]]: i32): // CHECK-NEXT: ^bb1(%[[V5:.*]]: i32):
// CHECK-NEXT: %[[V6:.*]] = arith.addi %[[V5]], %[[V4]] // CHECK-NEXT: %[[V6:.*]] = arith.addi %[[V5]], %[[V4]]
// CHECK-NEXT: "test.yield"(%[[V6]]) // CHECK-NEXT: "test.yield"(%[[V6]])
// CHECK-NEXT: }) // CHECK-NEXT: })
// CHECK-NEXT: %[[V2:.*]] = arith.addi %[[V0]], %[[V1]] // CHECK-NEXT: %[[V2:.*]] = arith.addi %[[V0]], %[[V1]]
// CHECK-NEXT: return %[[V2]] // CHECK-NEXT: return %[[V2]]
func @test_multiblock_region_sink(%arg0: i1, %arg1: i32, %arg2: i32) -> i32 { func @test_multiblock_region_sink(%arg0: i1, %arg1: i32, %arg2: i32) -> i32 {
%0 = arith.addi %arg1, %arg2 : i32 %0 = arith.addi %arg1, %arg2 : i32
%1 = arith.addi %0, %arg2 : i32 %1 = arith.addi %0, %arg2 : i32
%2 = arith.addi %1, %arg1 : i32 %2 = arith.addi %1, %arg1 : i32
%3 = "test.any_cond"() ({ %3 = "test.any_cond"() ({
br ^bb1(%2 : i32) cf.br ^bb1(%2 : i32)
^bb1(%5: i32): ^bb1(%5: i32):
%6 = arith.addi %5, %2 : i32 %6 = arith.addi %5, %2 : i32
"test.yield"(%6) : (i32) -> () "test.yield"(%6) : (i32) -> ()
}) : () -> i32 }) : () -> i32
%4 = arith.addi %0, %3 : i32 %4 = arith.addi %0, %3 : i32
return %4 : i32 return %4 : i32
} }
Show All 38 Lines
// Test that ops are only moved into the entry block, even when their only uses // Test that ops are only moved into the entry block, even when their only uses
// are further along. // are further along.
// CHECK-LABEL: @test_not_sunk_deeply // CHECK-LABEL: @test_not_sunk_deeply
// CHECK-SAME: (%[[ARG0:.*]]: i32) -> i32 { // CHECK-SAME: (%[[ARG0:.*]]: i32) -> i32 {
// CHECK-NEXT: %[[V0:.*]] = "test.any_cond"() ({ // CHECK-NEXT: %[[V0:.*]] = "test.any_cond"() ({
// CHECK-NEXT: %[[V1:.*]] = arith.addi %[[ARG0]], %[[ARG0]] // CHECK-NEXT: %[[V1:.*]] = arith.addi %[[ARG0]], %[[ARG0]]
// CHECK-NEXT: br ^bb1 // CHECK-NEXT: cf.br ^bb1
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
// CHECK-NEXT: "test.yield"(%[[V1]]) : (i32) -> () // CHECK-NEXT: "test.yield"(%[[V1]]) : (i32) -> ()
// CHECK-NEXT: }) // CHECK-NEXT: })
// CHECK-NEXT: return %[[V0]] // CHECK-NEXT: return %[[V0]]
func @test_not_sunk_deeply(%arg0: i32) -> i32 { func @test_not_sunk_deeply(%arg0: i32) -> i32 {
%0 = arith.addi %arg0, %arg0 : i32 %0 = arith.addi %arg0, %arg0 : i32
%1 = "test.any_cond"() ({ %1 = "test.any_cond"() ({
br ^bb1 cf.br ^bb1
^bb1: ^bb1:
"test.yield"(%0) : (i32) -> () "test.yield"(%0) : (i32) -> ()
}) : () -> i32 }) : () -> i32
return %1 : i32 return %1 : i32
} }

mlir/test/Transforms/cse.mlir

Show First 20 Lines • Show All 124 Lines • ▼ Show 20 Lines
// CHECK-LABEL: @down_propagate // CHECK-LABEL: @down_propagate
func @down_propagate() -> i32 { func @down_propagate() -> i32 {
// CHECK-NEXT: %c1_i32 = arith.constant 1 : i32 // CHECK-NEXT: %c1_i32 = arith.constant 1 : i32
%0 = arith.constant 1 : i32 %0 = arith.constant 1 : i32
// CHECK-NEXT: %true = arith.constant true // CHECK-NEXT: %true = arith.constant true
%cond = arith.constant true %cond = arith.constant true
// CHECK-NEXT: cond_br %true, ^bb1, ^bb2(%c1_i32 : i32) // CHECK-NEXT: cf.cond_br %true, ^bb1, ^bb2(%c1_i32 : i32)
cond_br %cond, ^bb1, ^bb2(%0 : i32) cf.cond_br %cond, ^bb1, ^bb2(%0 : i32)
^bb1: // CHECK: ^bb1: ^bb1: // CHECK: ^bb1:
// CHECK-NEXT: br ^bb2(%c1_i32 : i32) // CHECK-NEXT: cf.br ^bb2(%c1_i32 : i32)
%1 = arith.constant 1 : i32 %1 = arith.constant 1 : i32
br ^bb2(%1 : i32) cf.br ^bb2(%1 : i32)
^bb2(%arg : i32): ^bb2(%arg : i32):
return %arg : i32 return %arg : i32
} }
/// Check that operation definitions are NOT propagated up the dominance tree. /// Check that operation definitions are NOT propagated up the dominance tree.
// CHECK-LABEL: @up_propagate_for // CHECK-LABEL: @up_propagate_for
func @up_propagate_for() -> i32 { func @up_propagate_for() -> i32 {
Show All 14 Lines
// CHECK-LABEL: func @up_propagate // CHECK-LABEL: func @up_propagate
func @up_propagate() -> i32 { func @up_propagate() -> i32 {
// CHECK-NEXT: %c0_i32 = arith.constant 0 : i32 // CHECK-NEXT: %c0_i32 = arith.constant 0 : i32
%0 = arith.constant 0 : i32 %0 = arith.constant 0 : i32
// CHECK-NEXT: %true = arith.constant true // CHECK-NEXT: %true = arith.constant true
%cond = arith.constant true %cond = arith.constant true
// CHECK-NEXT: cond_br %true, ^bb1, ^bb2(%c0_i32 : i32) // CHECK-NEXT: cf.cond_br %true, ^bb1, ^bb2(%c0_i32 : i32)
cond_br %cond, ^bb1, ^bb2(%0 : i32) cf.cond_br %cond, ^bb1, ^bb2(%0 : i32)
^bb1: // CHECK: ^bb1: ^bb1: // CHECK: ^bb1:
// CHECK-NEXT: %c1_i32 = arith.constant 1 : i32 // CHECK-NEXT: %c1_i32 = arith.constant 1 : i32
%1 = arith.constant 1 : i32 %1 = arith.constant 1 : i32
// CHECK-NEXT: br ^bb2(%c1_i32 : i32) // CHECK-NEXT: cf.br ^bb2(%c1_i32 : i32)
br ^bb2(%1 : i32) cf.br ^bb2(%1 : i32)
^bb2(%arg : i32): // CHECK: ^bb2 ^bb2(%arg : i32): // CHECK: ^bb2
// CHECK-NEXT: %c1_i32_0 = arith.constant 1 : i32 // CHECK-NEXT: %c1_i32_0 = arith.constant 1 : i32
%2 = arith.constant 1 : i32 %2 = arith.constant 1 : i32
// CHECK-NEXT: %1 = arith.addi %0, %c1_i32_0 : i32 // CHECK-NEXT: %1 = arith.addi %0, %c1_i32_0 : i32
%add = arith.addi %arg, %2 : i32 %add = arith.addi %arg, %2 : i32
// CHECK-NEXT: return %1 : i32 // CHECK-NEXT: return %1 : i32
return %add : i32 return %add : i32
} }
/// The same test as above except that we are testing on a cfg embedded within /// The same test as above except that we are testing on a cfg embedded within
/// an operation region. /// an operation region.
// CHECK-LABEL: func @up_propagate_region // CHECK-LABEL: func @up_propagate_region
func @up_propagate_region() -> i32 { func @up_propagate_region() -> i32 {
// CHECK-NEXT: %0 = "foo.region" // CHECK-NEXT: %0 = "foo.region"
%0 = "foo.region"() ({ %0 = "foo.region"() ({
// CHECK-NEXT: %c0_i32 = arith.constant 0 : i32 // CHECK-NEXT: %c0_i32 = arith.constant 0 : i32
// CHECK-NEXT: %true = arith.constant true // CHECK-NEXT: %true = arith.constant true
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
%1 = arith.constant 0 : i32 %1 = arith.constant 0 : i32
%true = arith.constant true %true = arith.constant true
cond_br %true, ^bb1, ^bb2(%1 : i32) cf.cond_br %true, ^bb1, ^bb2(%1 : i32)
^bb1: // CHECK: ^bb1: ^bb1: // CHECK: ^bb1:
// CHECK-NEXT: %c1_i32 = arith.constant 1 : i32 // CHECK-NEXT: %c1_i32 = arith.constant 1 : i32
// CHECK-NEXT: br // CHECK-NEXT: cf.br
%c1_i32 = arith.constant 1 : i32 %c1_i32 = arith.constant 1 : i32
br ^bb2(%c1_i32 : i32) cf.br ^bb2(%c1_i32 : i32)
^bb2(%arg : i32): // CHECK: ^bb2(%1: i32): ^bb2(%arg : i32): // CHECK: ^bb2(%1: i32):
// CHECK-NEXT: %c1_i32_0 = arith.constant 1 : i32 // CHECK-NEXT: %c1_i32_0 = arith.constant 1 : i32
// CHECK-NEXT: %2 = arith.addi %1, %c1_i32_0 : i32 // CHECK-NEXT: %2 = arith.addi %1, %c1_i32_0 : i32
// CHECK-NEXT: "foo.yield"(%2) : (i32) -> () // CHECK-NEXT: "foo.yield"(%2) : (i32) -> ()
%c1_i32_0 = arith.constant 1 : i32 %c1_i32_0 = arith.constant 1 : i32
%2 = arith.addi %arg, %c1_i32_0 : i32 %2 = arith.addi %arg, %c1_i32_0 : i32
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

mlir/test/Transforms/inlining.mlir

Show All 14 Linesfunc @inline_with_arg(%arg0 : i32) -> i32 {
// CHECK-NEXT: return // CHECK-NEXT: return
%0 = call @func_with_arg(%arg0) : (i32) -> i32 %0 = call @func_with_arg(%arg0) : (i32) -> i32
return %0 : i32 return %0 : i32
} }
// Inline a function that has multiple return operations. // Inline a function that has multiple return operations.
func @func_with_multi_return(%a : i1) -> (i32) { func @func_with_multi_return(%a : i1) -> (i32) {
cond_br %a, ^bb1, ^bb2 cf.cond_br %a, ^bb1, ^bb2
^bb1: ^bb1:
%const_0 = arith.constant 0 : i32 %const_0 = arith.constant 0 : i32
return %const_0 : i32 return %const_0 : i32
^bb2: ^bb2:
%const_55 = arith.constant 55 : i32 %const_55 = arith.constant 55 : i32
return %const_55 : i32 return %const_55 : i32
} }
// CHECK-LABEL: func @inline_with_multi_return() -> i32 // CHECK-LABEL: func @inline_with_multi_return() -> i32
func @inline_with_multi_return() -> i32 { func @inline_with_multi_return() -> i32 {
// CHECK-NEXT: [[VAL_7:%.*]] = arith.constant false // CHECK-NEXT: [[VAL_7:%.*]] = arith.constant false
// CHECK-NEXT: cond_br [[VAL_7]], ^bb1, ^bb2 // CHECK-NEXT: cf.cond_br [[VAL_7]], ^bb1, ^bb2
// CHECK: ^bb1: // CHECK: ^bb1:
// CHECK-NEXT: [[VAL_8:%.*]] = arith.constant 0 : i32 // CHECK-NEXT: [[VAL_8:%.*]] = arith.constant 0 : i32
// CHECK-NEXT: br ^bb3([[VAL_8]] : i32) // CHECK-NEXT: cf.br ^bb3([[VAL_8]] : i32)
// CHECK: ^bb2: // CHECK: ^bb2:
// CHECK-NEXT: [[VAL_9:%.*]] = arith.constant 55 : i32 // CHECK-NEXT: [[VAL_9:%.*]] = arith.constant 55 : i32
// CHECK-NEXT: br ^bb3([[VAL_9]] : i32) // CHECK-NEXT: cf.br ^bb3([[VAL_9]] : i32)
// CHECK: ^bb3([[VAL_10:%.*]]: i32): // CHECK: ^bb3([[VAL_10:%.*]]: i32):
// CHECK-NEXT: return [[VAL_10]] : i32 // CHECK-NEXT: return [[VAL_10]] : i32
%false = arith.constant false %false = arith.constant false
%x = call @func_with_multi_return(%false) : (i1) -> i32 %x = call @func_with_multi_return(%false) : (i1) -> i32
return %x : i32 return %x : i32
} }
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Linesfunc @inline_convert_call() -> i16 {
// CHECK: %[[CAST_INPUT:.*]] = "test.cast"(%[[INPUT]]) : (i16) -> i32 // CHECK: %[[CAST_INPUT:.*]] = "test.cast"(%[[INPUT]]) : (i16) -> i32
// CHECK: %[[CAST_RESULT:.*]] = "test.cast"(%[[CAST_INPUT]]) : (i32) -> i16 // CHECK: %[[CAST_RESULT:.*]] = "test.cast"(%[[CAST_INPUT]]) : (i32) -> i16
// CHECK-NEXT: return %[[CAST_RESULT]] // CHECK-NEXT: return %[[CAST_RESULT]]
%res = "test.conversion_call_op"(%test_input) { callee=@convert_callee_fn } : (i16) -> (i16) %res = "test.conversion_call_op"(%test_input) { callee=@convert_callee_fn } : (i16) -> (i16)
return %res : i16 return %res : i16
} }
func @convert_callee_fn_multiblock() -> i32 { func @convert_callee_fn_multiblock() -> i32 {
br ^bb0 cf.br ^bb0
^bb0: ^bb0:
%0 = arith.constant 0 : i32 %0 = arith.constant 0 : i32
return %0 : i32 return %0 : i32
} }
// CHECK-LABEL: func @inline_convert_result_multiblock // CHECK-LABEL: func @inline_convert_result_multiblock
func @inline_convert_result_multiblock() -> i16 { func @inline_convert_result_multiblock() -> i16 {
// CHECK: br ^bb1 {inlined_conversion} // CHECK: cf.br ^bb1 {inlined_conversion}
// CHECK: ^bb1: // CHECK: ^bb1:
// CHECK: %[[C:.+]] = arith.constant {inlined_conversion} 0 : i32 // CHECK: %[[C:.+]] = arith.constant {inlined_conversion} 0 : i32
// CHECK: br ^bb2(%[[C]] : i32) // CHECK: cf.br ^bb2(%[[C]] : i32)
// CHECK: ^bb2(%[[BBARG:.+]]: i32): // CHECK: ^bb2(%[[BBARG:.+]]: i32):
// CHECK: %[[CAST_RESULT:.+]] = "test.cast"(%[[BBARG]]) : (i32) -> i16 // CHECK: %[[CAST_RESULT:.+]] = "test.cast"(%[[BBARG]]) : (i32) -> i16
// CHECK: return %[[CAST_RESULT]] : i16 // CHECK: return %[[CAST_RESULT]] : i16
%res = "test.conversion_call_op"() { callee=@convert_callee_fn_multiblock } : () -> (i16) %res = "test.conversion_call_op"() { callee=@convert_callee_fn_multiblock } : () -> (i16)
return %res : i16 return %res : i16
} }
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesfunc @inline_gpu_ops() -> memref<1024xf32> {
// CHECK-NEXT: gpu.alloc // CHECK-NEXT: gpu.alloc
%m = call @gpu_alloc() : () -> memref<1024xf32> %m = call @gpu_alloc() : () -> memref<1024xf32>
return %m : memref<1024xf32> return %m : memref<1024xf32>
} }
// Test block arguments location propagation. // Test block arguments location propagation.
// Use two call-sites to force cloning. // Use two call-sites to force cloning.
func @func_with_block_args_location(%arg0 : i32) { func @func_with_block_args_location(%arg0 : i32) {
br ^bb1(%arg0 : i32) cf.br ^bb1(%arg0 : i32)
^bb1(%x : i32 loc("foo")): ^bb1(%x : i32 loc("foo")):
"test.foo" (%x) : (i32) -> () loc("bar") "test.foo" (%x) : (i32) -> () loc("bar")
return return
} }
// INLINE-LOC-LABEL: func @func_with_block_args_location_callee1 // INLINE-LOC-LABEL: func @func_with_block_args_location_callee1
// INLINE-LOC: br // INLINE-LOC: cf.br
// INLINE-LOC: ^bb{{[0-9]+}}(%{{.*}}: i32 loc("foo") // INLINE-LOC: ^bb{{[0-9]+}}(%{{.*}}: i32 loc("foo")
func @func_with_block_args_location_callee1(%arg0 : i32) { func @func_with_block_args_location_callee1(%arg0 : i32) {
call @func_with_block_args_location(%arg0) : (i32) -> () call @func_with_block_args_location(%arg0) : (i32) -> ()
return return
} }
// CHECK-LABEL: func @func_with_block_args_location_callee2 // CHECK-LABEL: func @func_with_block_args_location_callee2
func @func_with_block_args_location_callee2(%arg0 : i32) { func @func_with_block_args_location_callee2(%arg0 : i32) {
call @func_with_block_args_location(%arg0) : (i32) -> () call @func_with_block_args_location(%arg0) : (i32) -> ()
return return
} }

mlir/test/Transforms/normalize-memrefs.mlir

Show First 20 Lines • Show All 200 Lines • ▼ Show 20 Lines
// Test case 4: Check successful memref normalization in case of inter/intra-recursive calls. // Test case 4: Check successful memref normalization in case of inter/intra-recursive calls.
// CHECK-LABEL: func @ret_multiple_argument_type // CHECK-LABEL: func @ret_multiple_argument_type
// CHECK-SAME: (%[[A:arg[0-9]+]]: memref<4x4xf64>, %[[B:arg[0-9]+]]: f64, %[[C:arg[0-9]+]]: memref<2x4xf64>) -> (memref<2x4xf64>, f64) // CHECK-SAME: (%[[A:arg[0-9]+]]: memref<4x4xf64>, %[[B:arg[0-9]+]]: f64, %[[C:arg[0-9]+]]: memref<2x4xf64>) -> (memref<2x4xf64>, f64)
func @ret_multiple_argument_type(%A: memref<16xf64, #tile>, %B: f64, %C: memref<8xf64, #tile>) -> (memref<8xf64, #tile>, f64) { func @ret_multiple_argument_type(%A: memref<16xf64, #tile>, %B: f64, %C: memref<8xf64, #tile>) -> (memref<8xf64, #tile>, f64) {
%a = affine.load %A[0] : memref<16xf64, #tile> %a = affine.load %A[0] : memref<16xf64, #tile>
%p = arith.mulf %a, %a : f64 %p = arith.mulf %a, %a : f64
%cond = arith.constant 1 : i1 %cond = arith.constant 1 : i1
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
%res1, %res2 = call @ret_single_argument_type(%C) : (memref<8xf64, #tile>) -> (memref<16xf64, #tile>, memref<8xf64, #tile>) %res1, %res2 = call @ret_single_argument_type(%C) : (memref<8xf64, #tile>) -> (memref<16xf64, #tile>, memref<8xf64, #tile>)
return %res2, %p: memref<8xf64, #tile>, f64 return %res2, %p: memref<8xf64, #tile>, f64
^bb2: ^bb2:
return %C, %p: memref<8xf64, #tile>, f64 return %C, %p: memref<8xf64, #tile>, f64
} }
// CHECK: %[[a:[0-9]+]] = affine.load %[[A]][0, 0] : memref<4x4xf64> // CHECK: %[[a:[0-9]+]] = affine.load %[[A]][0, 0] : memref<4x4xf64>
// CHECK: %[[p:[0-9]+]] = arith.mulf %[[a]], %[[a]] : f64 // CHECK: %[[p:[0-9]+]] = arith.mulf %[[a]], %[[a]] : f64
// CHECK: %true = arith.constant true // CHECK: %true = arith.constant true
// CHECK: cond_br %true, ^bb1, ^bb2 // CHECK: cf.cond_br %true, ^bb1, ^bb2
// CHECK: ^bb1: // pred: ^bb0 // CHECK: ^bb1: // pred: ^bb0
// CHECK: %[[res:[0-9]+]]:2 = call @ret_single_argument_type(%[[C]]) : (memref<2x4xf64>) -> (memref<4x4xf64>, memref<2x4xf64>) // CHECK: %[[res:[0-9]+]]:2 = call @ret_single_argument_type(%[[C]]) : (memref<2x4xf64>) -> (memref<4x4xf64>, memref<2x4xf64>)
// CHECK: return %[[res]]#1, %[[p]] : memref<2x4xf64>, f64 // CHECK: return %[[res]]#1, %[[p]] : memref<2x4xf64>, f64
// CHECK: ^bb2: // pred: ^bb0 // CHECK: ^bb2: // pred: ^bb0
// CHECK: return %{{.*}}, %{{.*}} : memref<2x4xf64>, f64 // CHECK: return %{{.*}}, %{{.*}} : memref<2x4xf64>, f64
// CHECK-LABEL: func @ret_single_argument_type // CHECK-LABEL: func @ret_single_argument_type
// CHECK-SAME: (%[[C:arg[0-9]+]]: memref<2x4xf64>) -> (memref<4x4xf64>, memref<2x4xf64>) // CHECK-SAME: (%[[C:arg[0-9]+]]: memref<2x4xf64>) -> (memref<4x4xf64>, memref<2x4xf64>)
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

mlir/test/Transforms/promote-buffers-to-stack.mlir

Show All 10 Lines
// bb1 bb2 <- Initial position of AllocOp // bb1 bb2 <- Initial position of AllocOp
// \ / // \ /
// bb3 // bb3
// PromoteBuffersToStack expected behavior: It should convert %0 into an // PromoteBuffersToStack expected behavior: It should convert %0 into an
// AllocaOp. // AllocaOp.
// CHECK-LABEL: func @condBranch // CHECK-LABEL: func @condBranch
func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: cond_br {{.*}} // CHECK-NEXT: cf.cond_br {{.*}}
// CHECK: ^bb2 // CHECK: ^bb2
// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca() // CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
// CHECK: test.copy // CHECK: test.copy
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// Test Case: // Test Case:
// bb0 // bb0
// / \ // / \
// bb1 bb2 <- Initial position of AllocOp // bb1 bb2 <- Initial position of AllocOp
// \ / // \ /
// bb3 // bb3
// PromoteBuffersToStack expected behavior: // PromoteBuffersToStack expected behavior:
// Since the alloc has dynamic type, it is not converted into an alloca. // Since the alloc has dynamic type, it is not converted into an alloca.
// CHECK-LABEL: func @condBranchDynamicType // CHECK-LABEL: func @condBranchDynamicType
func @condBranchDynamicType( func @condBranchDynamicType(
%arg0: i1, %arg0: i1,
%arg1: memref<?xf32>, %arg1: memref<?xf32>,
%arg2: memref<?xf32>, %arg2: memref<?xf32>,
%arg3: index) { %arg3: index) {
cond_br %arg0, ^bb1, ^bb2(%arg3: index) cf.cond_br %arg0, ^bb1, ^bb2(%arg3: index)
^bb1: ^bb1:
br ^bb3(%arg1 : memref<?xf32>) cf.br ^bb3(%arg1 : memref<?xf32>)
^bb2(%0: index): ^bb2(%0: index):
%1 = memref.alloc(%0) : memref<?xf32> %1 = memref.alloc(%0) : memref<?xf32>
test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>) test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>)
br ^bb3(%1 : memref<?xf32>) cf.br ^bb3(%1 : memref<?xf32>)
^bb3(%2: memref<?xf32>): ^bb3(%2: memref<?xf32>):
test.copy(%2, %arg2) : (memref<?xf32>, memref<?xf32>) test.copy(%2, %arg2) : (memref<?xf32>, memref<?xf32>)
return return
} }
// CHECK-NEXT: cond_br // CHECK-NEXT: cf.cond_br
// CHECK: ^bb2 // CHECK: ^bb2
// CHECK: ^bb2(%[[IDX:.*]]:{{.*}}) // CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc(%[[IDX]]) // CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc(%[[IDX]])
// CHECK-NEXT: test.buffer_based // CHECK-NEXT: test.buffer_based
// CHECK: br ^bb3 // CHECK: cf.br ^bb3
// CHECK-NEXT: ^bb3(%[[ALLOC0:.*]]:{{.*}}) // CHECK-NEXT: ^bb3(%[[ALLOC0:.*]]:{{.*}})
// CHECK: test.copy(%[[ALLOC0]], // CHECK: test.copy(%[[ALLOC0]],
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// CHECK-LABEL: func @dynamicRanked // CHECK-LABEL: func @dynamicRanked
func @dynamicRanked(%memref: memref<*xf32>) { func @dynamicRanked(%memref: memref<*xf32>) {
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
// | bb1 <- Initial position of AllocOp // | bb1 <- Initial position of AllocOp
// \ / // \ /
// bb2 // bb2
// PromoteBuffersToStack expected behavior: It should convert it into an // PromoteBuffersToStack expected behavior: It should convert it into an
// AllocaOp. // AllocaOp.
// CHECK-LABEL: func @criticalEdge // CHECK-LABEL: func @criticalEdge
func @criticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @criticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>) cf.cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>)
^bb1: ^bb1:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
br ^bb2(%0 : memref<2xf32>) cf.br ^bb2(%0 : memref<2xf32>)
^bb2(%1: memref<2xf32>): ^bb2(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: cond_br {{.*}} // CHECK-NEXT: cf.cond_br {{.*}}
// CHECK: ^bb1 // CHECK: ^bb1
// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca() // CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
// CHECK: test.copy // CHECK: test.copy
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// Test Case: // Test Case:
// bb0 <- Initial position of AllocOp // bb0 <- Initial position of AllocOp
// / \ // / \
// | bb1 // | bb1
// \ / // \ /
// bb2 // bb2
// PromoteBuffersToStack expected behavior: It converts the alloc in an alloca. // PromoteBuffersToStack expected behavior: It converts the alloc in an alloca.
// CHECK-LABEL: func @invCriticalEdge // CHECK-LABEL: func @invCriticalEdge
func @invCriticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @invCriticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>) cf.cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>)
^bb1: ^bb1:
br ^bb2(%0 : memref<2xf32>) cf.br ^bb2(%0 : memref<2xf32>)
^bb2(%1: memref<2xf32>): ^bb2(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca() // CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
// CHECK: cond_br // CHECK: cf.cond_br
// CHECK: test.copy // CHECK: test.copy
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// Test Case: // Test Case:
// bb0 <- Initial position of the first AllocOp // bb0 <- Initial position of the first AllocOp
// / \ // / \
// bb1 bb2 // bb1 bb2
// \ / // \ /
// bb3 <- Initial position of the second AllocOp // bb3 <- Initial position of the second AllocOp
// PromoteBuffersToStack expected behavior: It converts the allocs into allocas. // PromoteBuffersToStack expected behavior: It converts the allocs into allocas.
// CHECK-LABEL: func @ifElse // CHECK-LABEL: func @ifElse
func @ifElse(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @ifElse(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
cond_br %arg0, cf.cond_br %arg0,
^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>), ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>) ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
^bb1(%1: memref<2xf32>, %2: memref<2xf32>): ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>) cf.br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>)
^bb2(%3: memref<2xf32>, %4: memref<2xf32>): ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>) cf.br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>)
^bb3(%5: memref<2xf32>, %6: memref<2xf32>): ^bb3(%5: memref<2xf32>, %6: memref<2xf32>):
%7 = memref.alloc() : memref<2xf32> %7 = memref.alloc() : memref<2xf32>
test.buffer_based in(%5: memref<2xf32>) out(%7: memref<2xf32>) test.buffer_based in(%5: memref<2xf32>) out(%7: memref<2xf32>)
test.copy(%7, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%7, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOCA0:.*]] = memref.alloca() // CHECK-NEXT: %[[ALLOCA0:.*]] = memref.alloca()
Show All 12 Lines
// \ / // \ /
// bb3 // bb3
// PromoteBuffersToStack expected behavior: It converts the alloc into alloca. // PromoteBuffersToStack expected behavior: It converts the alloc into alloca.
// CHECK-LABEL: func @ifElseNoUsers // CHECK-LABEL: func @ifElseNoUsers
func @ifElseNoUsers(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @ifElseNoUsers(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
cond_br %arg0, cf.cond_br %arg0,
^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>), ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>) ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
^bb1(%1: memref<2xf32>, %2: memref<2xf32>): ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>) cf.br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>)
^bb2(%3: memref<2xf32>, %4: memref<2xf32>): ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>) cf.br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>)
^bb3(%5: memref<2xf32>, %6: memref<2xf32>): ^bb3(%5: memref<2xf32>, %6: memref<2xf32>):
test.copy(%arg1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%arg1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca() // CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
// CHECK: return // CHECK: return
Show All 10 Lines
// bb5 <- Initial position of the second AllocOp // bb5 <- Initial position of the second AllocOp
// PromoteBuffersToStack expected behavior: The two allocs should be converted // PromoteBuffersToStack expected behavior: The two allocs should be converted
// into allocas. // into allocas.
// CHECK-LABEL: func @ifElseNested // CHECK-LABEL: func @ifElseNested
func @ifElseNested(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @ifElseNested(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
cond_br %arg0, cf.cond_br %arg0,
^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>), ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>) ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
^bb1(%1: memref<2xf32>, %2: memref<2xf32>): ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>) cf.br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>)
^bb2(%3: memref<2xf32>, %4: memref<2xf32>): ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>) cf.cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>)
^bb3(%5: memref<2xf32>): ^bb3(%5: memref<2xf32>):
br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>) cf.br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>)
^bb4(%6: memref<2xf32>): ^bb4(%6: memref<2xf32>):
br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>) cf.br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>)
^bb5(%7: memref<2xf32>, %8: memref<2xf32>): ^bb5(%7: memref<2xf32>, %8: memref<2xf32>):
%9 = memref.alloc() : memref<2xf32> %9 = memref.alloc() : memref<2xf32>
test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>) test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>)
test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: %[[ALLOCA0:.*]] = memref.alloca() // CHECK-NEXT: %[[ALLOCA0:.*]] = memref.alloca()
Show All 36 Lines
// PromoteBuffersToStack expected behavior: Both AllocOps are converted into // PromoteBuffersToStack expected behavior: Both AllocOps are converted into
// allocas. // allocas.
// CHECK-LABEL: func @moving_alloc_and_inserting_missing_dealloc // CHECK-LABEL: func @moving_alloc_and_inserting_missing_dealloc
func @moving_alloc_and_inserting_missing_dealloc( func @moving_alloc_and_inserting_missing_dealloc(
%cond: i1, %cond: i1,
%arg0: memref<2xf32>, %arg0: memref<2xf32>,
%arg1: memref<2xf32>) { %arg1: memref<2xf32>) {
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>) test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>)
br ^exit(%0 : memref<2xf32>) cf.br ^exit(%0 : memref<2xf32>)
^bb2: ^bb2:
%1 = memref.alloc() : memref<2xf32> %1 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>) test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>)
br ^exit(%1 : memref<2xf32>) cf.br ^exit(%1 : memref<2xf32>)
^exit(%arg2: memref<2xf32>): ^exit(%arg2: memref<2xf32>):
test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>) test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: cond_br {{.*}} // CHECK-NEXT: cf.cond_br {{.*}}
// CHECK: ^bb1 // CHECK: ^bb1
// CHECK-NEXT: %{{.*}} = memref.alloca() // CHECK-NEXT: %{{.*}} = memref.alloca()
// CHECK: ^bb2 // CHECK: ^bb2
// CHECK-NEXT: %{{.*}} = memref.alloca() // CHECK-NEXT: %{{.*}} = memref.alloca()
// CHECK: test.copy // CHECK: test.copy
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
// Test Case: Nested regions - This test defines a BufferBasedOp inside the // Test Case: Nested regions - This test defines a BufferBasedOp inside the
// region of a RegionBufferBasedOp. // region of a RegionBufferBasedOp.
// PromoteBuffersToStack expected behavior: The AllocOps are converted into // PromoteBuffersToStack expected behavior: The AllocOps are converted into
// allocas. // allocas.
// CHECK-LABEL: func @nested_regions_and_cond_branch // CHECK-LABEL: func @nested_regions_and_cond_branch
func @nested_regions_and_cond_branch( func @nested_regions_and_cond_branch(
%arg0: i1, %arg0: i1,
%arg1: memref<2xf32>, %arg1: memref<2xf32>,
%arg2: memref<2xf32>) { %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) { test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) {
^bb0(%gen1_arg0: f32, %gen1_arg1: f32): ^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
%1 = memref.alloc() : memref<2xf32> %1 = memref.alloc() : memref<2xf32>
test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>) test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>)
%tmp1 = math.exp %gen1_arg0 : f32 %tmp1 = math.exp %gen1_arg0 : f32
test.region_yield %tmp1 : f32 test.region_yield %tmp1 : f32
} }
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>) test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
return return
} }
// CHECK-NEXT: cond_br {{.*}} // CHECK-NEXT: cf.cond_br {{.*}}
// CHECK: ^bb2 // CHECK: ^bb2
// CHECK-NEXT: %[[ALLOCA0:.*]] = memref.alloca() // CHECK-NEXT: %[[ALLOCA0:.*]] = memref.alloca()
// CHECK: ^bb0 // CHECK: ^bb0
// CHECK-NEXT: %[[ALLOCA1:.*]] = memref.alloc() // CHECK-NEXT: %[[ALLOCA1:.*]] = memref.alloc()
// ----- // -----
// Test Case: buffer deallocation escaping // Test Case: buffer deallocation escaping
▲ Show 20 Lines • Show All 227 Lines • Show Last 20 Lines

mlir/test/Transforms/sccp-callgraph.mlir

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Lines
// ----- // -----
/// Check a more complex interaction with calls and control flow. /// Check a more complex interaction with calls and control flow.
// CHECK-LABEL: func private @complex_inner_if( // CHECK-LABEL: func private @complex_inner_if(
func private @complex_inner_if(%arg0 : i32) -> i32 { func private @complex_inner_if(%arg0 : i32) -> i32 {
// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[TRUE:.*]] = arith.constant true
// CHECK-DAG: %[[CST:.*]] = arith.constant 1 : i32 // CHECK-DAG: %[[CST:.*]] = arith.constant 1 : i32
// CHECK: cond_br %[[TRUE]], ^bb1 // CHECK: cf.cond_br %[[TRUE]], ^bb1
%cst_20 = arith.constant 20 : i32 %cst_20 = arith.constant 20 : i32
%cond = arith.cmpi ult, %arg0, %cst_20 : i32 %cond = arith.cmpi ult, %arg0, %cst_20 : i32
cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
// CHECK: ^bb1: // CHECK: ^bb1:
// CHECK: return %[[CST]] : i32 // CHECK: return %[[CST]] : i32
%cst_1 = arith.constant 1 : i32 %cst_1 = arith.constant 1 : i32
return %cst_1 : i32 return %cst_1 : i32
^bb2: ^bb2:
%cst_1_2 = arith.constant 1 : i32 %cst_1_2 = arith.constant 1 : i32
%arg_inc = arith.addi %arg0, %cst_1_2 : i32 %arg_inc = arith.addi %arg0, %cst_1_2 : i32
return %arg_inc : i32 return %arg_inc : i32
} }
func private @complex_cond() -> i1 func private @complex_cond() -> i1
// CHECK-LABEL: func private @complex_callee( // CHECK-LABEL: func private @complex_callee(
func private @complex_callee(%arg0 : i32) -> i32 { func private @complex_callee(%arg0 : i32) -> i32 {
// CHECK: %[[CST:.*]] = arith.constant 1 : i32 // CHECK: %[[CST:.*]] = arith.constant 1 : i32
%loop_cond = call @complex_cond() : () -> i1 %loop_cond = call @complex_cond() : () -> i1
cond_br %loop_cond, ^bb1, ^bb2 cf.cond_br %loop_cond, ^bb1, ^bb2
^bb1: ^bb1:
// CHECK: ^bb1: // CHECK: ^bb1:
// CHECK-NEXT: return %[[CST]] : i32 // CHECK-NEXT: return %[[CST]] : i32
return %arg0 : i32 return %arg0 : i32
^bb2: ^bb2:
// CHECK: ^bb2: // CHECK: ^bb2:
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

mlir/test/Transforms/sccp.mlir

Show All 16 Lines
/// is taken. /// is taken.
// CHECK-LABEL: func @simple_control_flow // CHECK-LABEL: func @simple_control_flow
func @simple_control_flow(%arg0 : i32) -> i32 { func @simple_control_flow(%arg0 : i32) -> i32 {
// CHECK: %[[CST:.*]] = arith.constant 1 : i32 // CHECK: %[[CST:.*]] = arith.constant 1 : i32
%cond = arith.constant true %cond = arith.constant true
%1 = arith.constant 1 : i32 %1 = arith.constant 1 : i32
cond_br %cond, ^bb1, ^bb2(%arg0 : i32) cf.cond_br %cond, ^bb1, ^bb2(%arg0 : i32)
^bb1: ^bb1:
br ^bb2(%1 : i32) cf.br ^bb2(%1 : i32)
^bb2(%arg : i32): ^bb2(%arg : i32):
// CHECK: ^bb2(%{{.*}}: i32): // CHECK: ^bb2(%{{.*}}: i32):
// CHECK: return %[[CST]] : i32 // CHECK: return %[[CST]] : i32
return %arg : i32 return %arg : i32
} }
/// Check that the arguments go to overdefined if the branch cannot detect when /// Check that the arguments go to overdefined if the branch cannot detect when
/// a specific successor is taken. /// a specific successor is taken.
// CHECK-LABEL: func @simple_control_flow_overdefined // CHECK-LABEL: func @simple_control_flow_overdefined
func @simple_control_flow_overdefined(%arg0 : i32, %arg1 : i1) -> i32 { func @simple_control_flow_overdefined(%arg0 : i32, %arg1 : i1) -> i32 {
%1 = arith.constant 1 : i32 %1 = arith.constant 1 : i32
cond_br %arg1, ^bb1, ^bb2(%arg0 : i32) cf.cond_br %arg1, ^bb1, ^bb2(%arg0 : i32)
^bb1: ^bb1:
br ^bb2(%1 : i32) cf.br ^bb2(%1 : i32)
^bb2(%arg : i32): ^bb2(%arg : i32):
// CHECK: ^bb2(%[[ARG:.*]]: i32): // CHECK: ^bb2(%[[ARG:.*]]: i32):
// CHECK: return %[[ARG]] : i32 // CHECK: return %[[ARG]] : i32
return %arg : i32 return %arg : i32
} }
/// Check that the arguments go to overdefined if there are conflicting /// Check that the arguments go to overdefined if there are conflicting
/// constants. /// constants.
// CHECK-LABEL: func @simple_control_flow_constant_overdefined // CHECK-LABEL: func @simple_control_flow_constant_overdefined
func @simple_control_flow_constant_overdefined(%arg0 : i32, %arg1 : i1) -> i32 { func @simple_control_flow_constant_overdefined(%arg0 : i32, %arg1 : i1) -> i32 {
%1 = arith.constant 1 : i32 %1 = arith.constant 1 : i32
%2 = arith.constant 2 : i32 %2 = arith.constant 2 : i32
cond_br %arg1, ^bb1, ^bb2(%arg0 : i32) cf.cond_br %arg1, ^bb1, ^bb2(%arg0 : i32)
^bb1: ^bb1:
br ^bb2(%2 : i32) cf.br ^bb2(%2 : i32)
^bb2(%arg : i32): ^bb2(%arg : i32):
// CHECK: ^bb2(%[[ARG:.*]]: i32): // CHECK: ^bb2(%[[ARG:.*]]: i32):
// CHECK: return %[[ARG]] : i32 // CHECK: return %[[ARG]] : i32
return %arg : i32 return %arg : i32
} }
/// Check that the arguments go to overdefined if the branch is unknown. /// Check that the arguments go to overdefined if the branch is unknown.
// CHECK-LABEL: func @unknown_terminator // CHECK-LABEL: func @unknown_terminator
func @unknown_terminator(%arg0 : i32, %arg1 : i1) -> i32 { func @unknown_terminator(%arg0 : i32, %arg1 : i1) -> i32 {
%1 = arith.constant 1 : i32 %1 = arith.constant 1 : i32
"foo.cond_br"() [^bb1, ^bb2] : () -> () "foo.cond_br"() [^bb1, ^bb2] : () -> ()
^bb1: ^bb1:
br ^bb2(%1 : i32) cf.br ^bb2(%1 : i32)
^bb2(%arg : i32): ^bb2(%arg : i32):
// CHECK: ^bb2(%[[ARG:.*]]: i32): // CHECK: ^bb2(%[[ARG:.*]]: i32):
// CHECK: return %[[ARG]] : i32 // CHECK: return %[[ARG]] : i32
return %arg : i32 return %arg : i32
} }
/// Check that arguments are properly merged across loop-like control flow. /// Check that arguments are properly merged across loop-like control flow.
func private @ext_cond_fn() -> i1 func private @ext_cond_fn() -> i1
// CHECK-LABEL: func @simple_loop // CHECK-LABEL: func @simple_loop
func @simple_loop(%arg0 : i32, %cond1 : i1) -> i32 { func @simple_loop(%arg0 : i32, %cond1 : i1) -> i32 {
// CHECK: %[[CST:.*]] = arith.constant 1 : i32 // CHECK: %[[CST:.*]] = arith.constant 1 : i32
%cst_1 = arith.constant 1 : i32 %cst_1 = arith.constant 1 : i32
cond_br %cond1, ^bb1(%cst_1 : i32), ^bb2(%cst_1 : i32) cf.cond_br %cond1, ^bb1(%cst_1 : i32), ^bb2(%cst_1 : i32)
^bb1(%iv: i32): ^bb1(%iv: i32):
// CHECK: ^bb1(%{{.*}}: i32): // CHECK: ^bb1(%{{.*}}: i32):
// CHECK-NEXT: %[[COND:.*]] = call @ext_cond_fn() // CHECK-NEXT: %[[COND:.*]] = call @ext_cond_fn()
// CHECK-NEXT: cond_br %[[COND]], ^bb1(%[[CST]] : i32), ^bb2(%[[CST]] : i32) // CHECK-NEXT: cf.cond_br %[[COND]], ^bb1(%[[CST]] : i32), ^bb2(%[[CST]] : i32)
%cst_0 = arith.constant 0 : i32 %cst_0 = arith.constant 0 : i32
%res = arith.addi %iv, %cst_0 : i32 %res = arith.addi %iv, %cst_0 : i32
%cond2 = call @ext_cond_fn() : () -> i1 %cond2 = call @ext_cond_fn() : () -> i1
cond_br %cond2, ^bb1(%res : i32), ^bb2(%res : i32) cf.cond_br %cond2, ^bb1(%res : i32), ^bb2(%res : i32)
^bb2(%arg : i32): ^bb2(%arg : i32):
// CHECK: ^bb2(%{{.*}}: i32): // CHECK: ^bb2(%{{.*}}: i32):
// CHECK: return %[[CST]] : i32 // CHECK: return %[[CST]] : i32
return %arg : i32 return %arg : i32
} }
/// Test that we can properly propagate within inner control, and in situations /// Test that we can properly propagate within inner control, and in situations
/// where the executable edges within the CFG are sensitive to the current state /// where the executable edges within the CFG are sensitive to the current state
/// of the analysis. /// of the analysis.
// CHECK-LABEL: func @simple_loop_inner_control_flow // CHECK-LABEL: func @simple_loop_inner_control_flow
func @simple_loop_inner_control_flow(%arg0 : i32) -> i32 { func @simple_loop_inner_control_flow(%arg0 : i32) -> i32 {
// CHECK-DAG: %[[CST:.*]] = arith.constant 1 : i32 // CHECK-DAG: %[[CST:.*]] = arith.constant 1 : i32
// CHECK-DAG: %[[TRUE:.*]] = arith.constant true // CHECK-DAG: %[[TRUE:.*]] = arith.constant true
%cst_1 = arith.constant 1 : i32 %cst_1 = arith.constant 1 : i32
br ^bb1(%cst_1 : i32) cf.br ^bb1(%cst_1 : i32)
^bb1(%iv: i32): ^bb1(%iv: i32):
%cond2 = call @ext_cond_fn() : () -> i1 %cond2 = call @ext_cond_fn() : () -> i1
cond_br %cond2, ^bb5(%iv : i32), ^bb2 cf.cond_br %cond2, ^bb5(%iv : i32), ^bb2
^bb2: ^bb2:
// CHECK: ^bb2: // CHECK: ^bb2:
// CHECK: cond_br %[[TRUE]], ^bb3, ^bb4 // CHECK: cf.cond_br %[[TRUE]], ^bb3, ^bb4
%cst_20 = arith.constant 20 : i32 %cst_20 = arith.constant 20 : i32
%cond = arith.cmpi ult, %iv, %cst_20 : i32 %cond = arith.cmpi ult, %iv, %cst_20 : i32
cond_br %cond, ^bb3, ^bb4 cf.cond_br %cond, ^bb3, ^bb4
^bb3: ^bb3:
// CHECK: ^bb3: // CHECK: ^bb3:
// CHECK: br ^bb1(%[[CST]] : i32) // CHECK: cf.br ^bb1(%[[CST]] : i32)
%cst_1_2 = arith.constant 1 : i32 %cst_1_2 = arith.constant 1 : i32
br ^bb1(%cst_1_2 : i32) cf.br ^bb1(%cst_1_2 : i32)
^bb4: ^bb4:
%iv_inc = arith.addi %iv, %cst_1 : i32 %iv_inc = arith.addi %iv, %cst_1 : i32
br ^bb1(%iv_inc : i32) cf.br ^bb1(%iv_inc : i32)
^bb5(%result: i32): ^bb5(%result: i32):
// CHECK: ^bb5(%{{.*}}: i32): // CHECK: ^bb5(%{{.*}}: i32):
// CHECK: return %[[CST]] : i32 // CHECK: return %[[CST]] : i32
return %result : i32 return %result : i32
} }
/// Check that arguments go to overdefined when loop backedges produce a /// Check that arguments go to overdefined when loop backedges produce a
/// conflicting value. /// conflicting value.
func private @ext_cond_and_value_fn() -> (i1, i32) func private @ext_cond_and_value_fn() -> (i1, i32)
// CHECK-LABEL: func @simple_loop_overdefined // CHECK-LABEL: func @simple_loop_overdefined
func @simple_loop_overdefined(%arg0 : i32, %cond1 : i1) -> i32 { func @simple_loop_overdefined(%arg0 : i32, %cond1 : i1) -> i32 {
%cst_1 = arith.constant 1 : i32 %cst_1 = arith.constant 1 : i32
cond_br %cond1, ^bb1(%cst_1 : i32), ^bb2(%cst_1 : i32) cf.cond_br %cond1, ^bb1(%cst_1 : i32), ^bb2(%cst_1 : i32)
^bb1(%iv: i32): ^bb1(%iv: i32):
%cond2, %res = call @ext_cond_and_value_fn() : () -> (i1, i32) %cond2, %res = call @ext_cond_and_value_fn() : () -> (i1, i32)
cond_br %cond2, ^bb1(%res : i32), ^bb2(%res : i32) cf.cond_br %cond2, ^bb1(%res : i32), ^bb2(%res : i32)
^bb2(%arg : i32): ^bb2(%arg : i32):
// CHECK: ^bb2(%[[ARG:.*]]: i32): // CHECK: ^bb2(%[[ARG:.*]]: i32):
// CHECK: return %[[ARG]] : i32 // CHECK: return %[[ARG]] : i32
return %arg : i32 return %arg : i32
} }
// Check that we reprocess executable edges when information changes. // Check that we reprocess executable edges when information changes.
// CHECK-LABEL: func @recheck_executable_edge // CHECK-LABEL: func @recheck_executable_edge
func @recheck_executable_edge(%cond0: i1) -> (i1, i1) { func @recheck_executable_edge(%cond0: i1) -> (i1, i1) {
%true = arith.constant true %true = arith.constant true
%false = arith.constant false %false = arith.constant false
cond_br %cond0, ^bb_1a, ^bb2(%false : i1) cf.cond_br %cond0, ^bb_1a, ^bb2(%false : i1)
^bb_1a: ^bb_1a:
br ^bb2(%true : i1) cf.br ^bb2(%true : i1)
^bb2(%x: i1): ^bb2(%x: i1):
// CHECK: ^bb2(%[[X:.*]]: i1): // CHECK: ^bb2(%[[X:.*]]: i1):
br ^bb3(%x : i1) cf.br ^bb3(%x : i1)
^bb3(%y: i1): ^bb3(%y: i1):
// CHECK: ^bb3(%[[Y:.*]]: i1): // CHECK: ^bb3(%[[Y:.*]]: i1):
// CHECK: return %[[X]], %[[Y]] // CHECK: return %[[X]], %[[Y]]
return %x, %y : i1, i1 return %x, %y : i1, i1
} }

mlir/test/Transforms/test-legalizer-full.mlir

Show First 20 Lines • Show All 83 Lines • ▼ Show 20 Lines
// expected-remark@+1 {{applyFullConversion failed}} // expected-remark@+1 {{applyFullConversion failed}}
builtin.module { builtin.module {
// Test that region inlining can be properly undone. // Test that region inlining can be properly undone.
func @test_undo_region_inline() { func @test_undo_region_inline() {
"test.region"() ({ "test.region"() ({
^bb1(%i0: i64): ^bb1(%i0: i64):
// expected-error@+1 {{failed to legalize operation 'std.br'}} // expected-error@+1 {{failed to legalize operation 'cf.br'}}
br ^bb2(%i0 : i64) cf.br ^bb2(%i0 : i64)
^bb2(%i1: i64): ^bb2(%i1: i64):
"test.invalid"(%i1) : (i64) -> () "test.invalid"(%i1) : (i64) -> ()
}) {} : () -> () }) {} : () -> ()
"test.return"() : () -> () "test.return"() : () -> ()
} }
} }
// ----- // -----
// expected-remark@+1 {{applyFullConversion failed}} // expected-remark@+1 {{applyFullConversion failed}}
builtin.module { builtin.module {
// Test that multiple block erases can be properly undone. // Test that multiple block erases can be properly undone.
func @test_undo_block_erase() { func @test_undo_block_erase() {
// expected-error@+1 {{failed to legalize operation 'test.region'}} // expected-error@+1 {{failed to legalize operation 'test.region'}}
"test.region"() ({ "test.region"() ({
^bb1(%i0: i64): ^bb1(%i0: i64):
br ^bb2(%i0 : i64) cf.br ^bb2(%i0 : i64)
^bb2(%i1: i64): ^bb2(%i1: i64):
"test.invalid"(%i1) : (i64) -> () "test.invalid"(%i1) : (i64) -> ()
}) {legalizer.should_clone, legalizer.erase_old_blocks} : () -> () }) {legalizer.should_clone, legalizer.erase_old_blocks} : () -> ()
"test.return"() : () -> () "test.return"() : () -> ()
} }
} }
Show All 13 Lines

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

// RUN: mlir-opt %s -async-to-async-runtime \ // RUN: mlir-opt %s -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-linalg-to-loops \ // RUN: -convert-linalg-to-loops \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm \ // RUN: -convert-linalg-to-llvm \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-arith-to-llvm \ // RUN: -convert-arith-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -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=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \
Show All 15 Linesfunc @main() {
// CHECK: 0 // CHECK: 0
%err0 = async.runtime.is_error %token0 : !async.token %err0 = async.runtime.is_error %token0 : !async.token
vector.print %err0 : i1 vector.print %err0 : i1
// ------------------------------------------------------------------------ // // ------------------------------------------------------------------------ //
// Check that assertion in the async region converted to async error. // Check that assertion in the async region converted to async error.
// ------------------------------------------------------------------------ // // ------------------------------------------------------------------------ //
%token1 = async.execute { %token1 = async.execute {
assert %false, "error" cf.assert %false, "error"
async.yield async.yield
} }
async.runtime.await %token1 : !async.token async.runtime.await %token1 : !async.token
// CHECK: 1 // CHECK: 1
%err1 = async.runtime.is_error %token1 : !async.token %err1 = async.runtime.is_error %token1 : !async.token
vector.print %err1 : i1 vector.print %err1 : i1
// ------------------------------------------------------------------------ // // ------------------------------------------------------------------------ //
// Check error propagation from the nested region. // Check error propagation from the nested region.
// ------------------------------------------------------------------------ // // ------------------------------------------------------------------------ //
%token2 = async.execute { %token2 = async.execute {
%token = async.execute { %token = async.execute {
assert %false, "error" cf.assert %false, "error"
async.yield async.yield
} }
async.await %token : !async.token async.await %token : !async.token
async.yield async.yield
} }
async.runtime.await %token2 : !async.token async.runtime.await %token2 : !async.token
// CHECK: 1 // CHECK: 1
%err2 = async.runtime.is_error %token2 : !async.token %err2 = async.runtime.is_error %token2 : !async.token
vector.print %err2 : i1 vector.print %err2 : i1
// ------------------------------------------------------------------------ // // ------------------------------------------------------------------------ //
// Check error propagation from the nested region with async values. // Check error propagation from the nested region with async values.
// ------------------------------------------------------------------------ // // ------------------------------------------------------------------------ //
%token3, %value3 = async.execute -> !async.value<f32> { %token3, %value3 = async.execute -> !async.value<f32> {
%token, %value = async.execute -> !async.value<f32> { %token, %value = async.execute -> !async.value<f32> {
assert %false, "error" cf.assert %false, "error"
%0 = arith.constant 123.45 : f32 %0 = arith.constant 123.45 : f32
async.yield %0 : f32 async.yield %0 : f32
} }
%ret = async.await %value : !async.value<f32> %ret = async.await %value : !async.value<f32>
async.yield %ret : f32 async.yield %ret : f32
} }
async.runtime.await %token3 : !async.token async.runtime.await %token3 : !async.token
async.runtime.await %value3 : !async.value<f32> async.runtime.await %value3 : !async.value<f32>
Show All 12 Linesfunc @main() {
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%group0 = async.create_group %c2 : !async.group %group0 = async.create_group %c2 : !async.group
%token4 = async.execute { %token4 = async.execute {
async.yield async.yield
} }
%token5 = async.execute { %token5 = async.execute {
assert %false, "error" cf.assert %false, "error"
async.yield async.yield
} }
%idx0 = async.add_to_group %token4, %group0 : !async.token %idx0 = async.add_to_group %token4, %group0 : !async.token
%idx1 = async.add_to_group %token5, %group0 : !async.token %idx1 = async.add_to_group %token5, %group0 : !async.token
async.runtime.await %group0 : !async.group async.runtime.await %group0 : !async.group
// CHECK: 1 // CHECK: 1
%err4 = async.runtime.is_error %group0 : !async.group %err4 = async.runtime.is_error %group0 : !async.group
vector.print %err4 : i1 vector.print %err4 : i1
return return
} }

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

// RUN: mlir-opt %s -async-to-async-runtime \ // RUN: mlir-opt %s -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-linalg-to-loops \ // RUN: -convert-linalg-to-loops \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm \ // RUN: -convert-linalg-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-arith-to-llvm \ // RUN: -convert-arith-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -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=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-arith-to-llvm -convert-memref-to-llvm -convert-std-to-llvm='use-bare-ptr-memref-call-conv=1' -reconcile-unrealized-casts | mlir-cpu-runner -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext -entry-point-result=void | FileCheck %s // RUN: mlir-opt %s -convert-scf-to-cf -convert-arith-to-llvm -convert-memref-to-llvm -convert-std-to-llvm='use-bare-ptr-memref-call-conv=1' -reconcile-unrealized-casts | mlir-cpu-runner -shared-libs=%linalg_test_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 @simple_add1_add2_test(%arg0: memref<2xf32>, %arg1: memref<2xf32>) { 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 -convert-scf-to-std -convert-arith-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-arith-to-llvm -convert-memref-to-llvm -convert-std-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_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface } func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
func @main() -> () { 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/memref-reinterpret-cast.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-memref-to-llvm -convert-arith-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-memref-to-llvm -convert-arith-to-llvm -convert-std-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_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface } func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
func @main() -> () { 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 -convert-scf-to-std -memref-expand -convert-arith-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts \ // RUN: mlir-opt %s -convert-scf-to-cf -memref-expand -convert-arith-to-llvm -convert-memref-to-llvm -convert-std-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_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface } func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
func @main() -> () { func @main() -> () {
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

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

// RUN: mlir-opt -convert-linalg-to-loops -lower-affine -convert-scf-to-std -convert-arith-to-llvm -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts %s | mlir-cpu-runner -O3 -e main -entry-point-result=void -shared-libs=%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext | FileCheck %s // RUN: mlir-opt -convert-linalg-to-loops -lower-affine -convert-scf-to-cf -convert-arith-to-llvm -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts %s | mlir-cpu-runner -O3 -e main -entry-point-result=void -shared-libs=%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
func @main() { 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 -convert-linalg-to-loops \ // RUN: mlir-opt %s -convert-linalg-to-loops \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -convert-arith-to-llvm \ // RUN: -convert-arith-to-llvm \
// RUN: -convert-linalg-to-llvm \ // RUN: -convert-linalg-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts | \ // RUN: -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_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext | FileCheck %s // RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-arith-to-llvm -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e print_0d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-0D // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-arith-to-llvm -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e print_0d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-0D
// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-arith-to-llvm -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e print_1d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-1D // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-arith-to-llvm -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e print_1d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-1D
// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-arith-to-llvm -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e print_3d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-3D // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-arith-to-llvm -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e print_3d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-3D
// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-arith-to-llvm -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e vector_splat_2d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-VECTOR-SPLAT-2D // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-arith-to-llvm -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e vector_splat_2d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-VECTOR-SPLAT-2D
func @print_0d() { 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 @print_memref_f32(%U): (memref<*xf32>) -> () call @print_memref_f32(%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-lsp-server/hover.test

// RUN: mlir-lsp-server -lit-test < %s | FileCheck -strict-whitespace %s // RUN: mlir-lsp-server -lit-test < %s | FileCheck -strict-whitespace %s
{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"mlir","capabilities":{},"trace":"off"}} {"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"mlir","capabilities":{},"trace":"off"}}
// ----- // -----
{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{ {"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{
"uri":"test:///foo.mlir", "uri":"test:///foo.mlir",
"languageId":"mlir", "languageId":"mlir",
"version":1, "version":1,
"text":"func @foo(%arg: i1) {\n%value = arith.constant true\nbr ^bb2\n^bb2:\nreturn\n}" "text":"func @foo(%arg: i1) {\n%value = arith.constant true\ncf.br ^bb2\n^bb2:\nreturn\n}"
}}} }}}
// ----- // -----
// Hover on an operation. // Hover on an operation.
{"jsonrpc":"2.0","id":1,"method":"textDocument/hover","params":{ {"jsonrpc":"2.0","id":1,"method":"textDocument/hover","params":{
"textDocument":{"uri":"test:///foo.mlir"}, "textDocument":{"uri":"test:///foo.mlir"},
"position":{"line":1,"character":12} "position":{"line":1,"character":12}
}} }}
// CHECK: "id": 1, // CHECK: "id": 1,
▲ Show 20 Lines • Show All 141 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 -async-to-async-runtime \ // RUN: mlir-opt %s -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-linalg-to-loops \ // RUN: -convert-linalg-to-loops \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm \ // RUN: -convert-linalg-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-arith-to-llvm \ // RUN: -convert-arith-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// CHECK: llvm.func @async_execute_fn{{.*}}attributes{{.*}}"coroutine.presplit", "0" // CHECK: llvm.func @async_execute_fn{{.*}}attributes{{.*}}"coroutine.presplit", "0"
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

mlir/test/mlir-opt/commandline.mlir

// RUN: mlir-opt --show-dialects | FileCheck %s // RUN: mlir-opt --show-dialects | FileCheck %s
// CHECK: Available Dialects: // CHECK: Available Dialects:
// CHECK-NEXT: acc // CHECK-NEXT: acc
// CHECK-NEXT: affine // CHECK-NEXT: affine
// CHECK-NEXT: amx // CHECK-NEXT: amx
// CHECK-NEXT: arith // CHECK-NEXT: arith
// CHECK-NEXT: arm_neon // CHECK-NEXT: arm_neon
// CHECK-NEXT: arm_sve // CHECK-NEXT: arm_sve
// CHECK-NEXT: async // CHECK-NEXT: async
// CHECK-NEXT: bufferization // CHECK-NEXT: bufferization
// CHECK-NEXT: builtin // CHECK-NEXT: builtin
// CHECK-NEXT: cf
// CHECK-NEXT: complex // CHECK-NEXT: complex
// CHECK-NEXT: dlti // CHECK-NEXT: dlti
// CHECK-NEXT: emitc // CHECK-NEXT: emitc
// CHECK-NEXT: gpu // CHECK-NEXT: gpu
// CHECK-NEXT: linalg // CHECK-NEXT: linalg
// CHECK-NEXT: llvm // CHECK-NEXT: llvm
// CHECK-NEXT: math // CHECK-NEXT: math
// CHECK-NEXT: memref // CHECK-NEXT: memref
Show All 16 Lines

mlir/test/mlir-reduce/multiple-function.mlir

Show All 16 Lines
// CHECK-LABEL: func @simple3() { // CHECK-LABEL: func @simple3() {
func @simple3() { func @simple3() {
"test.op_crash" () : () -> () "test.op_crash" () : () -> ()
return return
} }
// CHECK-NOT: func @simple4() { // CHECK-NOT: func @simple4() {
func @simple4(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @simple4(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
"test.op_crash"(%1, %arg2) : (memref<2xf32>, memref<2xf32>) -> () "test.op_crash"(%1, %arg2) : (memref<2xf32>, memref<2xf32>) -> ()
return return
} }
// CHECK-NOT: func @simple5() { // CHECK-NOT: func @simple5() {
func @simple5() { func @simple5() {
return return
} }

mlir/test/mlir-reduce/simple-test.mlir

// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// RUN: mlir-reduce %s -reduction-tree='traversal-mode=0 test=%S/test.sh' // RUN: mlir-reduce %s -reduction-tree='traversal-mode=0 test=%S/test.sh'
func @simple1(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) { func @simple1(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2 cf.cond_br %arg0, ^bb1, ^bb2
^bb1: ^bb1:
br ^bb3(%arg1 : memref<2xf32>) cf.br ^bb3(%arg1 : memref<2xf32>)
^bb2: ^bb2:
%0 = memref.alloc() : memref<2xf32> %0 = memref.alloc() : memref<2xf32>
br ^bb3(%0 : memref<2xf32>) cf.br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>): ^bb3(%1: memref<2xf32>):
return return
} }

mlir/test/python/execution_engine.py

Show First 20 Lines • Show All 270 Lines • ▼ Show 20 Lines
def testDynamicMemrefAdd2D(): def testDynamicMemrefAdd2D():
with Context(): with Context():
module = Module.parse(""" module = Module.parse("""
module { module {
func @memref_add_2d(%arg0: memref<2x2xf32>, %arg1: memref<?x?xf32>, %arg2: memref<2x2xf32>) attributes {llvm.emit_c_interface} { func @memref_add_2d(%arg0: memref<2x2xf32>, %arg1: memref<?x?xf32>, %arg2: memref<2x2xf32>) attributes {llvm.emit_c_interface} {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
br ^bb1(%c0 : index) cf.br ^bb1(%c0 : index)
^bb1(%0: index): // 2 preds: ^bb0, ^bb5 ^bb1(%0: index): // 2 preds: ^bb0, ^bb5
%1 = arith.cmpi slt, %0, %c2 : index %1 = arith.cmpi slt, %0, %c2 : index
cond_br %1, ^bb2, ^bb6 cf.cond_br %1, ^bb2, ^bb6
^bb2: // pred: ^bb1 ^bb2: // pred: ^bb1
%c0_0 = arith.constant 0 : index %c0_0 = arith.constant 0 : index
%c2_1 = arith.constant 2 : index %c2_1 = arith.constant 2 : index
%c1_2 = arith.constant 1 : index %c1_2 = arith.constant 1 : index
br ^bb3(%c0_0 : index) cf.br ^bb3(%c0_0 : index)
^bb3(%2: index): // 2 preds: ^bb2, ^bb4 ^bb3(%2: index): // 2 preds: ^bb2, ^bb4
%3 = arith.cmpi slt, %2, %c2_1 : index %3 = arith.cmpi slt, %2, %c2_1 : index
cond_br %3, ^bb4, ^bb5 cf.cond_br %3, ^bb4, ^bb5
^bb4: // pred: ^bb3 ^bb4: // pred: ^bb3
%4 = memref.load %arg0[%0, %2] : memref<2x2xf32> %4 = memref.load %arg0[%0, %2] : memref<2x2xf32>
%5 = memref.load %arg1[%0, %2] : memref<?x?xf32> %5 = memref.load %arg1[%0, %2] : memref<?x?xf32>
%6 = arith.addf %4, %5 : f32 %6 = arith.addf %4, %5 : f32
memref.store %6, %arg2[%0, %2] : memref<2x2xf32> memref.store %6, %arg2[%0, %2] : memref<2x2xf32>
%7 = arith.addi %2, %c1_2 : index %7 = arith.addi %2, %c1_2 : index
br ^bb3(%7 : index) cf.br ^bb3(%7 : index)
^bb5: // pred: ^bb3 ^bb5: // pred: ^bb3
%8 = arith.addi %0, %c1 : index %8 = arith.addi %0, %c1 : index
br ^bb1(%8 : index) cf.br ^bb1(%8 : index)
^bb6: // pred: ^bb1 ^bb6: // pred: ^bb1
return return
} }
} }
""") """)
arg1 = np.random.randn(2, 2).astype(np.float32) arg1 = np.random.randn(2, 2).astype(np.float32)
arg2 = np.random.randn(2, 2).astype(np.float32) arg2 = np.random.randn(2, 2).astype(np.float32)
res = np.random.randn(2, 2).astype(np.float32) res = np.random.randn(2, 2).astype(np.float32)
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

mlir/test/python/integration/dialects/linalg/opsrun.py

Show First 20 Lines • Show All 122 Lines • ▼ Show 20 Linesdef transform(module, boilerplate):
# TODO: Allow cloning functions from one module to another. # TODO: Allow cloning functions from one module to another.
# Atm we have to resort to string concatenation. # Atm we have to resort to string concatenation.
mod = Module.parse( mod = Module.parse(
str(module.operation.regions[0].blocks[0].operations[0].operation) + str(module.operation.regions[0].blocks[0].operations[0].operation) +
boilerplate) boilerplate)
pm = PassManager.parse( pm = PassManager.parse(
"builtin.func(convert-linalg-to-loops, lower-affine, " + "builtin.func(convert-linalg-to-loops, lower-affine, " +
"convert-scf-to-std, arith-expand, memref-expand), convert-vector-to-llvm," + "convert-scf-to-cf, arith-expand, memref-expand), convert-vector-to-llvm," +
"convert-memref-to-llvm, convert-std-to-llvm," + "convert-memref-to-llvm, convert-std-to-llvm," +
"reconcile-unrealized-casts") "reconcile-unrealized-casts")
pm.run(mod) pm.run(mod)
return mod return mod
def test_matmul_builtin(): def test_matmul_builtin():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
▲ Show 20 Lines • Show All 238 Lines • Show Last 20 Lines

mlir/test/python/ir/blocks.py

Show All 13 Linesdef run(f):
f() f()
gc.collect() gc.collect()
assert Context._get_live_count() == 0 assert Context._get_live_count() == 0
return f return f
# CHECK-LABEL: TEST: testBlockCreation # CHECK-LABEL: TEST: testBlockCreation
# CHECK: func @test(%[[ARG0:.*]]: i32, %[[ARG1:.*]]: i16) # CHECK: func @test(%[[ARG0:.*]]: i32, %[[ARG1:.*]]: i16)
# CHECK: br ^bb1(%[[ARG1]] : i16) # CHECK: cf.br ^bb1(%[[ARG1]] : i16)
# CHECK: ^bb1(%[[PHI0:.*]]: i16): # CHECK: ^bb1(%[[PHI0:.*]]: i16):
# CHECK: br ^bb2(%[[ARG0]] : i32) # CHECK: cf.br ^bb2(%[[ARG0]] : i32)
# CHECK: ^bb2(%[[PHI1:.*]]: i32): # CHECK: ^bb2(%[[PHI1:.*]]: i32):
# CHECK: return # CHECK: return
@run @run
def testBlockCreation(): def testBlockCreation():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
with InsertionPoint(module.body): with InsertionPoint(module.body):
f_type = FunctionType.get( f_type = FunctionType.get(
Show All 40 Lines

mlir/test/python/ir/dialects.py

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Linesdef testCustomOpView():
m.operation.print() m.operation.print()
# CHECK-LABEL: TEST: testIsRegisteredOperation # CHECK-LABEL: TEST: testIsRegisteredOperation
@run @run
def testIsRegisteredOperation(): def testIsRegisteredOperation():
ctx = Context() ctx = Context()
# CHECK: std.cond_br: True # CHECK: cf.cond_br: True
print(f"std.cond_br: {ctx.is_registered_operation('std.cond_br')}") print(f"cf.cond_br: {ctx.is_registered_operation('cf.cond_br')}")
# CHECK: std.not_existing: False # CHECK: std.not_existing: False
print(f"std.not_existing: {ctx.is_registered_operation('std.not_existing')}") print(f"std.not_existing: {ctx.is_registered_operation('std.not_existing')}")
mlir/include/mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h