This is an archive of the discontinued LLVM Phabricator instance.

Differential D121266

[mlir] Move the Builtin FuncOp to the Func dialect
ClosedPublic

Authored by rriddle on Mar 8 2022, 5:22 PM.

Details

Reviewers
antiagainst
aartbik
jpienaar
ftynse
bondhugula
nicolasvasilache
herhut
mehdi_amini
sjarus
Commits
rG36550692340e: [mlir] Move the Builtin FuncOp to the Func dialect
Summary

This commit moves FuncOp out of the builtin dialect, and into the Func
dialect. This move has been planned in some capacity from the moment
we made FuncOp an operation (years ago). This commit handles the
functional aspects of the move, but various aspects are left untouched
to ease migration: func::FuncOp is re-exported into mlir to reduce
the actual API churn, the assembly format still accepts the unqualified
func. These temporary measures will remain for a little while to
simplify migration before being removed.

Diff Detail

Event Timeline

rriddle created this revision.Mar 8 2022, 5:22 PM
Herald added a reviewer: antiagainst. · View Herald TranscriptMar 8 2022, 5:22 PM
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: jpienaar. · 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 a project: Restricted Project. · View Herald Transcript
Herald added subscribers: awarzynski, sdasgup3, wenzhicui and 25 others. · View Herald Transcript
rriddle requested review of this revision.Mar 8 2022, 5:22 PM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptMar 8 2022, 5:22 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: D121267: [mlir][NOT FOR REVIEW] The test changes necessary for moving FuncOp out of builtin.Mar 8 2022, 5:22 PM
rriddle added a reviewer: mehdi_amini.Mar 8 2022, 5:24 PM
Harbormaster completed remote builds in B153274: Diff 413980.Mar 8 2022, 6:02 PM
zero9178 added a subscriber: zero9178.Mar 9 2022, 1:39 AM
mehdi_amini added a comment.Mar 14 2022, 9:58 PM

Can you rebase this patch?

mlir/test/lib/Dialect/Affine/TestAffineDataCopy.cpp
26

Oh that was just unused? This isn't related to this patch though right?

mehdi_amini added a comment.Mar 14 2022, 9:59 PM
In D121266#3381502, @mehdi_amini wrote:

Can you rebase this patch?

Maybe the whole chain of patches, I can't arc patch it right now unfortunately.

rriddle updated this revision to Diff 415330.Mar 15 2022, 12:06 AM
rriddle edited the summary of this revision. (Show Details)
Harbormaster completed remote builds in B154258: Diff 415330.Mar 15 2022, 12:30 AM
rriddle updated this revision to Diff 415649.Mar 15 2022, 5:41 PM
Harbormaster completed remote builds in B154475: Diff 415649.Mar 15 2022, 5:41 PM
mehdi_amini accepted this revision.Mar 16 2022, 12:57 PM
This revision was not accepted when it landed; it landed in state Needs Review.Mar 16 2022, 5:15 PM
This revision was landed with ongoing or failed builds.
Closed by commit rG36550692340e: [mlir] Move the Builtin FuncOp to the Func dialect (authored by rriddle). · Explain Why
This revision was automatically updated to reflect the committed changes.
rriddle marked an inline comment as done.
rriddle added a commit: rG36550692340e: [mlir] Move the Builtin FuncOp to the Func dialect.
Herald added a reviewer: sjarus. · View Herald TranscriptMar 16 2022, 5:15 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: armkevincheng, jsmolens, eric-k256, zzheng. · View Herald Transcript
thopre added a subscriber: thopre.Apr 1 2022, 1:29 PM

Note: there is still a few reference to mlir::FuncOp in the tree: most notably in the toy example:

mlir/examples/toy/Ch5/mlir/LowerToAffineLoops.cpp:    auto func = rewriter.create<mlir::FuncOp>(op.getLoc(), op.getName(),
mlir/examples/toy/Ch5/toyc.cpp:    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
mlir/examples/toy/Ch6/mlir/LowerToAffineLoops.cpp:    auto func = rewriter.create<mlir::FuncOp>(op.getLoc(), op.getName(),
mlir/examples/toy/Ch6/toyc.cpp:    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
mlir/examples/toy/Ch7/mlir/LowerToAffineLoops.cpp:    auto func = rewriter.create<mlir::FuncOp>(op.getLoc(), op.getName(),
mlir/examples/toy/Ch7/toyc.cpp:    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
mlir/lib/Dialect/Linalg/Transforms/HoistPadding.cpp:  AsmState state(padOp->getParentOfType<mlir::FuncOp>());
mlir/test/lib/Dialect/Test/TestOps.td:  let builders = [OpBuilder<(ins "::mlir::FuncOp":$function)>];
Herald added a subscriber: jdoerfert. · View Herald TranscriptApr 1 2022, 1:29 PM
rriddle added a comment.Apr 1 2022, 1:32 PM
In D121266#3423322, @thopre wrote:

Note: there is still a few reference to mlir::FuncOp in the tree: most notably in the toy example:

mlir/examples/toy/Ch5/mlir/LowerToAffineLoops.cpp:    auto func = rewriter.create<mlir::FuncOp>(op.getLoc(), op.getName(),
mlir/examples/toy/Ch5/toyc.cpp:    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
mlir/examples/toy/Ch6/mlir/LowerToAffineLoops.cpp:    auto func = rewriter.create<mlir::FuncOp>(op.getLoc(), op.getName(),
mlir/examples/toy/Ch6/toyc.cpp:    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
mlir/examples/toy/Ch7/mlir/LowerToAffineLoops.cpp:    auto func = rewriter.create<mlir::FuncOp>(op.getLoc(), op.getName(),
mlir/examples/toy/Ch7/toyc.cpp:    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
mlir/lib/Dialect/Linalg/Transforms/HoistPadding.cpp:  AsmState state(padOp->getParentOfType<mlir::FuncOp>());
mlir/test/lib/Dialect/Test/TestOps.td:  let builders = [OpBuilder<(ins "::mlir::FuncOp":$function)>];

Yeah, thanks. I haven't gotten around to actually updating the in-tree references, this commit was just the minimal set to get
everything to build after the move.

mlir/test/lib/Dialect/Affine/TestAffineDataCopy.cpp
26

Yep, also good point (will remove in an NFC patch before landing this).

Revision Contents

PathSize
flang/
include/
flang/
Lower/
1 line
Optimizer/
Builder/
1 line
8 lines
test/
Fir/
Todo/
2 lines
2 lines
unittests/
Optimizer/
Builder/
3 lines
3 lines
3 lines
Runtime/
3 lines
mlir/
benchmark/
python/
2 lines
8 lines
docs/
Bindings/
6 lines
Dialects/
2 lines
38 lines
6 lines
2 lines
include/
mlir/
Dialect/
Affine/
13 lines
38 lines
7 lines
Bufferization/
Transforms/
6 lines
10 lines
Func/
IR/
24 lines
115 lines
Transforms/
4 lines
GPU/
6 lines
Linalg/
Analysis/
5 lines
54 lines
Transforms/
6 lines
Quant/
8 lines
SCF/
Utils/
14 lines
Shape/
IR/
1 line
IR/
14 lines
116 lines
2 lines
lib/
Conversion/
GPUToNVVM/
1 line
GPUToROCDL/
1 line
LinalgToSPIRV/
1 line
MemRefToLLVM/
1 line
ShapeToStandard/
1 line
Dialect/
Affine/
Analysis/
1 line
Transforms/
1 line
Utils/
1 line
3 lines
1 line
Bufferization/
IR/
1 line
1 line
Transforms/
1 line
Func/
IR/
131 lines
Transforms/
2 lines
GPU/
Transforms/
1 line
1 line
Linalg/
Analysis/
1 line
Transforms/
1 line
1 line
2 lines
1 line
1 line
Quant/
Transforms/
1 line
1 line
SCF/
Transforms/
7 lines
SPIRV/
Transforms/
1 line
1 line
1 line
Shape/
IR/
1 line
Transforms/
1 line
SparseTensor/
Pipelines/
1 line
Transforms/
1 line
Tensor/
Transforms/
1 line
Vector/
Transforms/
1 line
IR/
125 lines
Pass/
2 lines
Target/
LLVMIR/
3 lines
Transforms/
Utils/
6 lines
python/
mlir/
dialects/
212 lines
213 lines
test/
Analysis/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
CAPI/
2 lines
2 lines
27 lines
Conversion/
ArithmeticToLLVM/
2 lines
2 lines
ComplexToStandard/
2 lines
2 lines
FuncToLLVM/
4 lines
4 lines
GPUToNVVM/
46 lines
12 lines
GPUToROCDL/
42 lines
MathToLLVM/
2 lines
SCFToGPU/
4 lines
4 lines
2 lines
ShapeToStandard/
2 lines
TosaToLinalg/
2 lines
2 lines
VectorToGPU/
2 lines
VectorToROCDL/
12 lines
VectorToSCF/
2 lines
2 lines
2 lines
2 lines
4 lines
Dialect/
Affine/
2 lines
2 lines
2 lines
ControlFlow/
2 lines
LLVMIR/
2 lines
Linalg/
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
12 lines
4 lines
Quant/
2 lines
SCF/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
SPIRV/
Transforms/
2 lines
Shape/
6 lines
Tensor/
2 lines
Vector/
2 lines
IR/
2 lines
22 lines
4 lines
10 lines
2 lines
2 lines
2 lines
2 lines
4 lines
30 lines
2 lines
Integration/
Dialect/
Linalg/
CPU/
4 lines
6 lines
SparseTensor/
python/
3 lines
3 lines
2 lines
taco/
tools/
2 lines
Standard/
CPU/
2 lines
Vector/
CPU/
8 lines
8 lines
8 lines
4 lines
4 lines
6 lines
Pass/
8 lines
2 lines
2 lines
18 lines
18 lines
10 lines
18 lines
6 lines
2 lines
Target/
Cpp/
2 lines
LLVMIR/
2 lines
2 lines
Transforms/
2 lines
4 lines
4 lines
4 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
lib/
Dialect/
Affine/
3 lines
1 line
1 line
1 line
Linalg/
3 lines
1 line
1 line
1 line
1 line
SCF/
1 line
SPIRV/
1 line
Test/
1 line
Tosa/
1 line
Vector/
2 lines
Pass/
1 line
mlir-cpu-runner/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
mlir-lsp-server/
2 lines
8 lines
mlir-opt/
2 lines
mlir-pdll/
Parser/
4 lines
2 lines
python/
dialects/
40 lines
8 lines
linalg/
opdsl/
2 lines
6 lines
18 lines
18 lines
12 lines
18 lines
4 lines
12 lines
4 lines
4 lines
4 lines
integration/
dialects/
linalg/
42 lines
ir/
4 lines
6 lines
16 lines
unittests/
ExecutionEngine/
1 line
IR/
23 lines
Pass/
3 lines
1 line
2 lines

Diff 416029

flang/include/flang/Lower/CallInterface.h

Show All 23 Lines
// or subroutine. // or subroutine.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef FORTRAN_LOWER_CALLINTERFACE_H #ifndef FORTRAN_LOWER_CALLINTERFACE_H
#define FORTRAN_LOWER_CALLINTERFACE_H #define FORTRAN_LOWER_CALLINTERFACE_H
#include "flang/Common/reference.h" #include "flang/Common/reference.h"
#include "flang/Evaluate/characteristics.h" #include "flang/Evaluate/characteristics.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include <memory> #include <memory>
#include <optional> #include <optional>
namespace Fortran::semantics { namespace Fortran::semantics {
class Symbol; class Symbol;
} }
▲ Show 20 Lines • Show All 375 Lines • Show Last 20 Lines

flang/include/flang/Optimizer/Builder/FIRBuilder.h

Show All 13 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef FORTRAN_OPTIMIZER_BUILDER_FIRBUILDER_H #ifndef FORTRAN_OPTIMIZER_BUILDER_FIRBUILDER_H
#define FORTRAN_OPTIMIZER_BUILDER_FIRBUILDER_H #define FORTRAN_OPTIMIZER_BUILDER_FIRBUILDER_H
#include "flang/Optimizer/Dialect/FIROps.h" #include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Dialect/FIRType.h" #include "flang/Optimizer/Dialect/FIRType.h"
#include "flang/Optimizer/Support/KindMapping.h" #include "flang/Optimizer/Support/KindMapping.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
namespace fir { namespace fir {
class AbstractArrayBox; class AbstractArrayBox;
class ExtendedValue; class ExtendedValue;
class BoxValue; class BoxValue;
▲ Show 20 Lines • Show All 512 Lines • Show Last 20 Lines

flang/include/flang/Optimizer/Builder/LowLevelIntrinsics.h

//===-- LowLevelIntrinsics.h ------------------------------------*- C++ -*-===// //===-- LowLevelIntrinsics.h ------------------------------------*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/ // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef FLANG_OPTIMIZER_BUILDER_LOWLEVELINTRINSICS_H #ifndef FLANG_OPTIMIZER_BUILDER_LOWLEVELINTRINSICS_H
#define FLANG_OPTIMIZER_BUILDER_LOWLEVELINTRINSICS_H #define FLANG_OPTIMIZER_BUILDER_LOWLEVELINTRINSICS_H
namespace mlir { namespace mlir {
namespace func {
class FuncOp; class FuncOp;
} } // namespace func
} // namespace mlir
namespace fir { namespace fir {
class FirOpBuilder; class FirOpBuilder;
} }
namespace fir::factory { namespace fir::factory {
/// Get the `llvm.stacksave` intrinsic. /// Get the `llvm.stacksave` intrinsic.
mlir::FuncOp getLlvmStackSave(FirOpBuilder &builder); mlir::func::FuncOp getLlvmStackSave(FirOpBuilder &builder);
/// Get the `llvm.stackrestore` intrinsic. /// Get the `llvm.stackrestore` intrinsic.
mlir::FuncOp getLlvmStackRestore(FirOpBuilder &builder); mlir::func::FuncOp getLlvmStackRestore(FirOpBuilder &builder);
} // namespace fir::factory } // namespace fir::factory
#endif // FLANG_OPTIMIZER_BUILDER_LOWLEVELINTRINSICS_H #endif // FLANG_OPTIMIZER_BUILDER_LOWLEVELINTRINSICS_H

flang/test/Fir/Todo/boxproc_host.fir

// RUN: not fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s // RUN: not fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
// Test that `fir.boxproc_host` fails conversion to llvm. // Test that `fir.boxproc_host` fails conversion to llvm.
// At the moment this test fails since `fir.boxproc` type does not have a conversion. // At the moment this test fails since `fir.boxproc` type does not have a conversion.
// CHECK: failed to legalize operation 'builtin.func' // CHECK: failed to legalize operation 'func.func'
func @test(%bproc: !fir.boxproc<(i32) -> ()>) { func @test(%bproc: !fir.boxproc<(i32) -> ()>) {
%tuple = fir.boxproc_host %bproc : (!fir.boxproc<(i32) -> ()>) -> (!fir.ref<tuple<i32,f64>>) %tuple = fir.boxproc_host %bproc : (!fir.boxproc<(i32) -> ()>) -> (!fir.ref<tuple<i32,f64>>)
return return
} }

flang/test/Fir/Todo/unboxproc.fir

// RUN: not fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s // RUN: not fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
// Test `fir.unboxproc` conversion to llvm. // Test `fir.unboxproc` conversion to llvm.
// Not implemented yet. // Not implemented yet.
// Currently fails since coversion for boxproc type is not implemented. // Currently fails since coversion for boxproc type is not implemented.
// CHECK: failed to legalize operation 'builtin.func' // CHECK: failed to legalize operation 'func.func'
func @boxing_match(%bproc: !fir.boxproc<(i32) -> ()>) { func @boxing_match(%bproc: !fir.boxproc<(i32) -> ()>) {
%ubproc:2 = fir.unboxproc %bproc : (!fir.boxproc<(i32) -> ()>) -> ((i32) -> (), !fir.ref<tuple<i32,f64>>) %ubproc:2 = fir.unboxproc %bproc : (!fir.boxproc<(i32) -> ()>) -> ((i32) -> (), !fir.ref<tuple<i32,f64>>)
return return
} }

flang/unittests/Optimizer/Builder/CharacterTest.cpp

Show All 10 Lines
#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/Support/InitFIR.h" #include "flang/Optimizer/Support/InitFIR.h"
#include "flang/Optimizer/Support/KindMapping.h" #include "flang/Optimizer/Support/KindMapping.h"
struct CharacterTest : public testing::Test { struct CharacterTest : public testing::Test {
public: public:
void SetUp() override { void SetUp() override {
fir::support::loadDialects(context);
kindMap = std::make_unique<fir::KindMapping>(&context, kindMap = std::make_unique<fir::KindMapping>(&context,
"i10:80,l3:24,a1:8,r54:Double,c20:X86_FP80,r11:PPC_FP128," "i10:80,l3:24,a1:8,r54:Double,c20:X86_FP80,r11:PPC_FP128,"
"r12:FP128,r13:X86_FP80,r14:Double,r15:Float,r16:Half,r23:BFloat"); "r12:FP128,r13:X86_FP80,r14:Double,r15:Float,r16:Half,r23:BFloat");
mlir::OpBuilder builder(&context); mlir::OpBuilder builder(&context);
auto loc = builder.getUnknownLoc(); auto loc = builder.getUnknownLoc();
// Set up a Module with a dummy function operation inside. // Set up a Module with a dummy function operation inside.
// Set the insertion point in the function entry block. // Set the insertion point in the function entry block.
mlir::ModuleOp mod = builder.create<mlir::ModuleOp>(loc); mlir::ModuleOp mod = builder.create<mlir::ModuleOp>(loc);
mlir::FuncOp func = mlir::FuncOp::create( mlir::FuncOp func = mlir::FuncOp::create(
loc, "func1", builder.getFunctionType(llvm::None, llvm::None)); loc, "func1", builder.getFunctionType(llvm::None, llvm::None));
auto *entryBlock = func.addEntryBlock(); auto *entryBlock = func.addEntryBlock();
mod.push_back(mod); mod.push_back(mod);
builder.setInsertionPointToStart(entryBlock); builder.setInsertionPointToStart(entryBlock);
fir::support::loadDialects(context);
firBuilder = std::make_unique<fir::FirOpBuilder>(mod, *kindMap); firBuilder = std::make_unique<fir::FirOpBuilder>(mod, *kindMap);
} }
fir::FirOpBuilder &getBuilder() { return *firBuilder; } fir::FirOpBuilder &getBuilder() { return *firBuilder; }
mlir::MLIRContext context; mlir::MLIRContext context;
std::unique_ptr<fir::KindMapping> kindMap; std::unique_ptr<fir::KindMapping> kindMap;
std::unique_ptr<fir::FirOpBuilder> firBuilder; std::unique_ptr<fir::FirOpBuilder> firBuilder;
Show All 30 Lines

flang/unittests/Optimizer/Builder/ComplexTest.cpp

Show All 9 Lines
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "flang/Optimizer/Builder/FIRBuilder.h" #include "flang/Optimizer/Builder/FIRBuilder.h"
#include "flang/Optimizer/Support/InitFIR.h" #include "flang/Optimizer/Support/InitFIR.h"
#include "flang/Optimizer/Support/KindMapping.h" #include "flang/Optimizer/Support/KindMapping.h"
struct ComplexTest : public testing::Test { struct ComplexTest : public testing::Test {
public: public:
void SetUp() override { void SetUp() override {
fir::support::loadDialects(context);
mlir::OpBuilder builder(&context); mlir::OpBuilder builder(&context);
auto loc = builder.getUnknownLoc(); auto loc = builder.getUnknownLoc();
// Set up a Module with a dummy function operation inside. // Set up a Module with a dummy function operation inside.
// Set the insertion point in the function entry block. // Set the insertion point in the function entry block.
mlir::ModuleOp mod = builder.create<mlir::ModuleOp>(loc); mlir::ModuleOp mod = builder.create<mlir::ModuleOp>(loc);
mlir::FuncOp func = mlir::FuncOp::create( mlir::FuncOp func = mlir::FuncOp::create(
loc, "func1", builder.getFunctionType(llvm::None, llvm::None)); loc, "func1", builder.getFunctionType(llvm::None, llvm::None));
auto *entryBlock = func.addEntryBlock(); auto *entryBlock = func.addEntryBlock();
mod.push_back(mod); mod.push_back(mod);
builder.setInsertionPointToStart(entryBlock); builder.setInsertionPointToStart(entryBlock);
fir::support::loadDialects(context);
kindMap = std::make_unique<fir::KindMapping>(&context); kindMap = std::make_unique<fir::KindMapping>(&context);
firBuilder = std::make_unique<fir::FirOpBuilder>(mod, *kindMap); firBuilder = std::make_unique<fir::FirOpBuilder>(mod, *kindMap);
helper = std::make_unique<fir::factory::Complex>(*firBuilder, loc); helper = std::make_unique<fir::factory::Complex>(*firBuilder, loc);
// Init commonly used types // Init commonly used types
realTy1 = mlir::FloatType::getF32(&context); realTy1 = mlir::FloatType::getF32(&context);
complexTy1 = fir::ComplexType::get(&context, 4); complexTy1 = fir::ComplexType::get(&context, 4);
integerTy1 = mlir::IntegerType::get(&context, 32); integerTy1 = mlir::IntegerType::get(&context, 32);
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp

Show All 11 Lines
#include "flang/Optimizer/Support/InitFIR.h" #include "flang/Optimizer/Support/InitFIR.h"
#include "flang/Optimizer/Support/KindMapping.h" #include "flang/Optimizer/Support/KindMapping.h"
using namespace mlir; using namespace mlir;
struct FIRBuilderTest : public testing::Test { struct FIRBuilderTest : public testing::Test {
public: public:
void SetUp() override { void SetUp() override {
fir::support::loadDialects(context);
llvm::ArrayRef<fir::KindTy> defs; llvm::ArrayRef<fir::KindTy> defs;
fir::KindMapping kindMap(&context, defs); fir::KindMapping kindMap(&context, defs);
mlir::OpBuilder builder(&context); mlir::OpBuilder builder(&context);
auto loc = builder.getUnknownLoc(); auto loc = builder.getUnknownLoc();
// Set up a Module with a dummy function operation inside. // Set up a Module with a dummy function operation inside.
// Set the insertion point in the function entry block. // Set the insertion point in the function entry block.
mlir::ModuleOp mod = builder.create<mlir::ModuleOp>(loc); mlir::ModuleOp mod = builder.create<mlir::ModuleOp>(loc);
mlir::FuncOp func = mlir::FuncOp::create( mlir::FuncOp func = mlir::FuncOp::create(
loc, "func1", builder.getFunctionType(llvm::None, llvm::None)); loc, "func1", builder.getFunctionType(llvm::None, llvm::None));
auto *entryBlock = func.addEntryBlock(); auto *entryBlock = func.addEntryBlock();
mod.push_back(mod); mod.push_back(mod);
builder.setInsertionPointToStart(entryBlock); builder.setInsertionPointToStart(entryBlock);
fir::support::loadDialects(context);
firBuilder = std::make_unique<fir::FirOpBuilder>(mod, kindMap); firBuilder = std::make_unique<fir::FirOpBuilder>(mod, kindMap);
} }
fir::FirOpBuilder &getBuilder() { return *firBuilder; } fir::FirOpBuilder &getBuilder() { return *firBuilder; }
mlir::MLIRContext context; mlir::MLIRContext context;
std::unique_ptr<fir::FirOpBuilder> firBuilder; std::unique_ptr<fir::FirOpBuilder> firBuilder;
}; };
▲ Show 20 Lines • Show All 487 Lines • Show Last 20 Lines

flang/unittests/Optimizer/Builder/Runtime/RuntimeCallTestBase.h

Show All 11 Lines
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "flang/Optimizer/Builder/FIRBuilder.h" #include "flang/Optimizer/Builder/FIRBuilder.h"
#include "flang/Optimizer/Support/InitFIR.h" #include "flang/Optimizer/Support/InitFIR.h"
#include "flang/Optimizer/Support/KindMapping.h" #include "flang/Optimizer/Support/KindMapping.h"
struct RuntimeCallTest : public testing::Test { struct RuntimeCallTest : public testing::Test {
public: public:
void SetUp() override { void SetUp() override {
fir::support::loadDialects(context);
mlir::OpBuilder builder(&context); mlir::OpBuilder builder(&context);
auto loc = builder.getUnknownLoc(); auto loc = builder.getUnknownLoc();
// Set up a Module with a dummy function operation inside. // Set up a Module with a dummy function operation inside.
// Set the insertion point in the function entry block. // Set the insertion point in the function entry block.
mlir::ModuleOp mod = builder.create<mlir::ModuleOp>(loc); mlir::ModuleOp mod = builder.create<mlir::ModuleOp>(loc);
mlir::FuncOp func = mlir::FuncOp::create(loc, "runtime_unit_tests_func", mlir::FuncOp func = mlir::FuncOp::create(loc, "runtime_unit_tests_func",
builder.getFunctionType(llvm::None, llvm::None)); builder.getFunctionType(llvm::None, llvm::None));
auto *entryBlock = func.addEntryBlock(); auto *entryBlock = func.addEntryBlock();
mod.push_back(mod); mod.push_back(mod);
builder.setInsertionPointToStart(entryBlock); builder.setInsertionPointToStart(entryBlock);
fir::support::loadDialects(context);
kindMap = std::make_unique<fir::KindMapping>(&context); kindMap = std::make_unique<fir::KindMapping>(&context);
firBuilder = std::make_unique<fir::FirOpBuilder>(mod, *kindMap); firBuilder = std::make_unique<fir::FirOpBuilder>(mod, *kindMap);
i1Ty = firBuilder->getI1Type(); i1Ty = firBuilder->getI1Type();
i8Ty = firBuilder->getI8Type(); i8Ty = firBuilder->getI8Type();
i16Ty = firBuilder->getIntegerType(16); i16Ty = firBuilder->getIntegerType(16);
i32Ty = firBuilder->getI32Type(); i32Ty = firBuilder->getI32Type();
i64Ty = firBuilder->getI64Type(); i64Ty = firBuilder->getI64Type();
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

mlir/benchmark/python/benchmark_sparse.py

Show All 37 Linesdef benchmark_sparse_mlir_multiplication():
""" """
with ir.Context(), ir.Location.unknown(): with ir.Context(), ir.Location.unknown():
module = ir.Module.create() module = ir.Module.create()
f64 = ir.F64Type.get() f64 = ir.F64Type.get()
param1_type = ir.RankedTensorType.get([1000, 1500], f64) param1_type = ir.RankedTensorType.get([1000, 1500], f64)
param2_type = ir.RankedTensorType.get([1500, 2000], f64) param2_type = ir.RankedTensorType.get([1500, 2000], f64)
result_type = ir.RankedTensorType.get([1000, 2000], f64) result_type = ir.RankedTensorType.get([1000, 2000], f64)
with ir.InsertionPoint(module.body): with ir.InsertionPoint(module.body):
@builtin.FuncOp.from_py_func(param1_type, param2_type, result_type) @func.FuncOp.from_py_func(param1_type, param2_type, result_type)
def sparse_kernel(x, y, z): def sparse_kernel(x, y, z):
return matmul_dsl(x, y, outs=[z]) return matmul_dsl(x, y, outs=[z])
def compiler(): def compiler():
with ir.Context(), ir.Location.unknown(): with ir.Context(), ir.Location.unknown():
kernel_func = get_kernel_func_from_module(module) kernel_func = get_kernel_func_from_module(module)
timer_func = emit_timer_func() timer_func = emit_timer_func()
wrapped_func = emit_benchmark_wrapped_main_func( wrapped_func = emit_benchmark_wrapped_main_func(
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

mlir/benchmark/python/common.py

Show All 35 Linesdef create_sparse_np_tensor(dimensions, number_of_elements):
for tensor_indices in tensor_indices_list: for tensor_indices in tensor_indices_list:
current_tensor = tensor current_tensor = tensor
for tensor_index in tensor_indices[:-1]: for tensor_index in tensor_indices[:-1]:
current_tensor = current_tensor[tensor_index] current_tensor = current_tensor[tensor_index]
current_tensor[tensor_indices[-1]] = np.random.uniform(1, 100) current_tensor[tensor_indices[-1]] = np.random.uniform(1, 100)
return tensor return tensor
def get_kernel_func_from_module(module: ir.Module) -> builtin.FuncOp: def get_kernel_func_from_module(module: ir.Module) -> func.FuncOp:
"""Takes an mlir module object and extracts the function object out of it. """Takes an mlir module object and extracts the function object out of it.
This function only works for a module with one region, one block, and one This function only works for a module with one region, one block, and one
operation. operation.
""" """
assert len(module.operation.regions) == 1, \ assert len(module.operation.regions) == 1, \
"Expected kernel module to have only one region" "Expected kernel module to have only one region"
assert len(module.operation.regions[0].blocks) == 1, \ assert len(module.operation.regions[0].blocks) == 1, \
"Expected kernel module to have only one block" "Expected kernel module to have only one block"
assert len(module.operation.regions[0].blocks[0].operations) == 1, \ assert len(module.operation.regions[0].blocks[0].operations) == 1, \
"Expected kernel module to have only one operation" "Expected kernel module to have only one operation"
return module.operation.regions[0].blocks[0].operations[0] return module.operation.regions[0].blocks[0].operations[0]
def emit_timer_func() -> builtin.FuncOp: def emit_timer_func() -> func.FuncOp:
"""Returns the declaration of nano_time function. If nano_time function is """Returns the declaration of nano_time function. If nano_time function is
used, the `MLIR_RUNNER_UTILS` and `MLIR_C_RUNNER_UTILS` must be included. used, the `MLIR_RUNNER_UTILS` and `MLIR_C_RUNNER_UTILS` must be included.
""" """
i64_type = ir.IntegerType.get_signless(64) i64_type = ir.IntegerType.get_signless(64)
nano_time = builtin.FuncOp( nano_time = func.FuncOp(
"nano_time", ([], [i64_type]), visibility="private") "nano_time", ([], [i64_type]), visibility="private")
nano_time.attributes["llvm.emit_c_interface"] = ir.UnitAttr.get() nano_time.attributes["llvm.emit_c_interface"] = ir.UnitAttr.get()
return nano_time return nano_time
def emit_benchmark_wrapped_main_func(func, timer_func): def emit_benchmark_wrapped_main_func(func, timer_func):
"""Takes a function and a timer function, both represented as FuncOp """Takes a function and a timer function, both represented as FuncOp
objects, and returns a new function. This new function wraps the call to objects, and returns a new function. This new function wraps the call to
the original function between calls to the timer_func and this wrapping the original function between calls to the timer_func and this wrapping
in turn is executed inside a loop. The loop is executed in turn is executed inside a loop. The loop is executed
len(func.type.results) times. This function can be used to create a len(func.type.results) times. This function can be used to create a
"time measuring" variant of a function. "time measuring" variant of a function.
""" """
i64_type = ir.IntegerType.get_signless(64) i64_type = ir.IntegerType.get_signless(64)
memref_of_i64_type = ir.MemRefType.get([-1], i64_type) memref_of_i64_type = ir.MemRefType.get([-1], i64_type)
wrapped_func = builtin.FuncOp( wrapped_func = func.FuncOp(
# Same signature and an extra buffer of indices to save timings. # Same signature and an extra buffer of indices to save timings.
"main", "main",
(func.arguments.types + [memref_of_i64_type], func.type.results), (func.arguments.types + [memref_of_i64_type], func.type.results),
visibility="public" visibility="public"
) )
wrapped_func.attributes["llvm.emit_c_interface"] = ir.UnitAttr.get() wrapped_func.attributes["llvm.emit_c_interface"] = ir.UnitAttr.get()
num_results = len(func.type.results) num_results = len(func.type.results)
Show All 20 Lines

mlir/docs/Bindings/Python.md

Show First 20 Lines • Show All 633 Lines • ▼ Show 20 Lines
```python ```python
from mlir.ir import Context, Module from mlir.ir import Context, Module
from mlir.dialects import builtin from mlir.dialects import builtin
with Context(): with Context():
module = Module.create() module = Module.create()
with InsertionPoint(module.body), Location.unknown(): with InsertionPoint(module.body), Location.unknown():
func = builtin.FuncOp("main", ([], [])) func = func.FuncOp("main", ([], []))
``` ```
Also see below for constructors generated from ODS. Also see below for constructors generated from ODS.
Operations can also be constructed using the generic class and based on the Operations can also be constructed using the generic class and based on the
canonical string name of the operation using `Operation.create`. It accepts the canonical string name of the operation using `Operation.create`. It accepts the
operation name as string, which must exactly match the canonical name of the operation name as string, which must exactly match the canonical name of the
operation in C++ or ODS, followed by the same argument list as the default operation in C++ or ODS, followed by the same argument list as the default
constructor for `OpView`. *This form is discouraged* from use and is intended constructor for `OpView`. *This form is discouraged* from use and is intended
for generic operation processing. for generic operation processing.
```python ```python
from mlir.ir import Context, Module from mlir.ir import Context, Module
from mlir.dialects import builtin from mlir.dialects import builtin
with Context(): with Context():
module = Module.create() module = Module.create()
with InsertionPoint(module.body), Location.unknown(): with InsertionPoint(module.body), Location.unknown():
# Operations can be created in a generic way. # Operations can be created in a generic way.
func = Operation.create( func = Operation.create(
"builtin.func", results=[], operands=[], "func.func", results=[], operands=[],
attributes={"type":TypeAttr.get(FunctionType.get([], []))}, attributes={"type":TypeAttr.get(FunctionType.get([], []))},
successors=None, regions=1) successors=None, regions=1)
# The result will be downcasted to the concrete `OpView` subclass if # The result will be downcasted to the concrete `OpView` subclass if
# available. # available.
assert isinstance(func, builtin.FuncOp) assert isinstance(func, func.FuncOp)
``` ```
Regions are created for an operation when constructing it on the C++ side. They Regions are created for an operation when constructing it on the C++ side. They
are not constructible in Python and are not expected to exist outside of are not constructible in Python and are not expected to exist outside of
operations (unlike in C++ that supports detached regions). operations (unlike in C++ that supports detached regions).
Blocks can be created within a given region and inserted before or after another Blocks can be created within a given region and inserted before or after another
block of the same region using `create_before()`, `create_after()` methods of block of the same region using `create_before()`, `create_after()` methods of
▲ Show 20 Lines • Show All 497 Lines • Show Last 20 Lines

mlir/docs/Dialects/ShapeDialect.md

Show All 28 Lines
a matmul. a matmul.
Starting from the shape function of matmul in the error monadic form Starting from the shape function of matmul in the error monadic form
below[^wip_form1]: below[^wip_form1]:
```mlir ```mlir
shape.function_library @shplib { shape.function_library @shplib {
builtin.func @matmul(%lhs: !shape.value_shape, %rhs: !shape.value_shape) -> !shape.shape { func.func @matmul(%lhs: !shape.value_shape, %rhs: !shape.value_shape) -> !shape.shape {
%c1 = shape.const_size 1 %c1 = shape.const_size 1
%c2 = shape.const_size 2 %c2 = shape.const_size 2
// We could also allow rank etc operations directly on value_shape too, that // We could also allow rank etc operations directly on value_shape too, that
// would make it nicer as "input" language, but keeping it explicit inside the // would make it nicer as "input" language, but keeping it explicit inside the
// IR instead and then we could have helper methods in front-end language. // IR instead and then we could have helper methods in front-end language.
%lhs_shape = shape.shape_of %lhs : !shape.value_shape -> !shape.shape %lhs_shape = shape.shape_of %lhs : !shape.value_shape -> !shape.shape
%rhs_shape = shape.shape_of %rhs : !shape.value_shape -> !shape.shape %rhs_shape = shape.shape_of %rhs : !shape.value_shape -> !shape.shape
%lhs_rank = shape.rank %lhs_shape : !shape.shape -> !shape.size %lhs_rank = shape.rank %lhs_shape : !shape.shape -> !shape.size
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

mlir/docs/PassManagement.md

Show First 20 Lines • Show All 526 Lines • ▼ Show 20 Lines
``` ```
The collected statistics may be aggregated in two types of views: The collected statistics may be aggregated in two types of views:
A pipeline view that models the structure of the pass manager, this is the A pipeline view that models the structure of the pass manager, this is the
default view: default view:
```shell ```shell
$ mlir-opt -pass-pipeline='builtin.func(my-pass,my-pass)' foo.mlir -pass-statistics $ mlir-opt -pass-pipeline='func.func(my-pass,my-pass)' foo.mlir -pass-statistics
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
... Pass statistics report ... ... Pass statistics report ...
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
'builtin.func' Pipeline 'func.func' Pipeline
MyPass MyPass
(S) 15 exampleStat - An example statistic (S) 15 exampleStat - An example statistic
VerifierPass VerifierPass
MyPass MyPass
(S) 6 exampleStat - An example statistic (S) 6 exampleStat - An example statistic
VerifierPass VerifierPass
VerifierPass VerifierPass
``` ```
A list view that aggregates the statistics of all instances of a specific pass A list view that aggregates the statistics of all instances of a specific pass
together: together:
```shell ```shell
$ mlir-opt -pass-pipeline='builtin.func(my-pass, my-pass)' foo.mlir -pass-statistics -pass-statistics-display=list $ mlir-opt -pass-pipeline='func.func(my-pass, my-pass)' foo.mlir -pass-statistics -pass-statistics-display=list
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
... Pass statistics report ... ... Pass statistics report ...
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
MyPass MyPass
(S) 21 exampleStat - An example statistic (S) 21 exampleStat - An example statistic
``` ```
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines
```ebnf ```ebnf
pipeline ::= op-name `(` pipeline-element (`,` pipeline-element)* `)` pipeline ::= op-name `(` pipeline-element (`,` pipeline-element)* `)`
pipeline-element ::= pipeline | (pass-name | pass-pipeline-name) options? pipeline-element ::= pipeline | (pass-name | pass-pipeline-name) options?
options ::= '{' (key ('=' value)?)+ '}' options ::= '{' (key ('=' value)?)+ '}'
``` ```
* `op-name` * `op-name`
* This corresponds to the mnemonic name of an operation to run passes on, * This corresponds to the mnemonic name of an operation to run passes on,
e.g. `builtin.func` or `builtin.module`. e.g. `func.func` or `builtin.module`.
* `pass-name` | `pass-pipeline-name` * `pass-name` | `pass-pipeline-name`
* This corresponds to the argument of a registered pass or pass pipeline, * This corresponds to the argument of a registered pass or pass pipeline,
e.g. `cse` or `canonicalize`. e.g. `cse` or `canonicalize`.
* `options` * `options`
* Options are specific key value pairs representing options defined by a * Options are specific key value pairs representing options defined by a
pass or pass pipeline, as described in the pass or pass pipeline, as described in the
["Instance Specific Pass Options"](#instance-specific-pass-options) ["Instance Specific Pass Options"](#instance-specific-pass-options)
section. See this section for an example usage in a textual pipeline. section. See this section for an example usage in a textual pipeline.
For example, the following pipeline: For example, the following pipeline:
```shell ```shell
$ mlir-opt foo.mlir -cse -canonicalize -convert-func-to-llvm='use-bare-ptr-memref-call-conv=1' $ mlir-opt foo.mlir -cse -canonicalize -convert-func-to-llvm='use-bare-ptr-memref-call-conv=1'
``` ```
Can also be specified as (via the `-pass-pipeline` flag): Can also be specified as (via the `-pass-pipeline` flag):
```shell ```shell
$ mlir-opt foo.mlir -pass-pipeline='builtin.func(cse,canonicalize),convert-func-to-llvm{use-bare-ptr-memref-call-conv=1}' $ mlir-opt foo.mlir -pass-pipeline='func.func(cse,canonicalize),convert-func-to-llvm{use-bare-ptr-memref-call-conv=1}'
``` ```
In order to support round-tripping a pass to the textual representation using In order to support round-tripping a pass to the textual representation using
`OpPassManager::printAsTextualPipeline(raw_ostream&)`, override `StringRef `OpPassManager::printAsTextualPipeline(raw_ostream&)`, override `StringRef
Pass::getArgument()` to specify the argument used when registering a pass. Pass::getArgument()` to specify the argument used when registering a pass.
## Declarative Pass Specification ## Declarative Pass Specification
▲ Show 20 Lines • Show All 304 Lines • ▼ Show 20 Lines
In this mode, the results are displayed in a list sorted by total time with each In this mode, the results are displayed in a list sorted by total time with each
pass/analysis instance aggregated into one unique result. This view is useful pass/analysis instance aggregated into one unique result. This view is useful
for getting an overview of what analyses/passes are taking the most time in a for getting an overview of what analyses/passes are taking the most time in a
pipeline. This display mode is available in mlir-opt via pipeline. This display mode is available in mlir-opt via
`-mlir-timing-display=list`. `-mlir-timing-display=list`.
```shell ```shell
$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='builtin.func(cse,canonicalize)' -convert-func-to-llvm -mlir-timing -mlir-timing-display=list $ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='func.func(cse,canonicalize)' -convert-func-to-llvm -mlir-timing -mlir-timing-display=list
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
... Pass execution timing report ... ... Pass execution timing report ...
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
Total Execution Time: 0.0203 seconds Total Execution Time: 0.0203 seconds
---Wall Time--- --- Name --- ---Wall Time--- --- Name ---
0.0047 ( 55.9%) Canonicalizer 0.0047 ( 55.9%) Canonicalizer
0.0019 ( 22.2%) VerifierPass 0.0019 ( 22.2%) VerifierPass
0.0016 ( 18.5%) LLVMLoweringPass 0.0016 ( 18.5%) LLVMLoweringPass
0.0003 ( 3.4%) CSE 0.0003 ( 3.4%) CSE
0.0002 ( 1.9%) (A) DominanceInfo 0.0002 ( 1.9%) (A) DominanceInfo
0.0084 (100.0%) Total 0.0084 (100.0%) Total
``` ```
##### Tree Display Mode ##### Tree Display Mode
In this mode, the results are displayed in a nested pipeline view that mirrors In this mode, the results are displayed in a nested pipeline view that mirrors
the internal pass pipeline that is being executed in the pass manager. This view the internal pass pipeline that is being executed in the pass manager. This view
is useful for understanding specifically which parts of the pipeline are taking is useful for understanding specifically which parts of the pipeline are taking
the most time, and can also be used to identify when analyses are being the most time, and can also be used to identify when analyses are being
invalidated and recomputed. This is the default display mode. invalidated and recomputed. This is the default display mode.
```shell ```shell
$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='builtin.func(cse,canonicalize)' -convert-func-to-llvm -mlir-timing $ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='func.func(cse,canonicalize)' -convert-func-to-llvm -mlir-timing
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
... Pass execution timing report ... ... Pass execution timing report ...
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
Total Execution Time: 0.0249 seconds Total Execution Time: 0.0249 seconds
---Wall Time--- --- Name --- ---Wall Time--- --- Name ---
0.0058 ( 70.8%) 'builtin.func' Pipeline 0.0058 ( 70.8%) 'func.func' Pipeline
0.0004 ( 4.3%) CSE 0.0004 ( 4.3%) CSE
0.0002 ( 2.6%) (A) DominanceInfo 0.0002 ( 2.6%) (A) DominanceInfo
0.0004 ( 4.8%) VerifierPass 0.0004 ( 4.8%) VerifierPass
0.0046 ( 55.4%) Canonicalizer 0.0046 ( 55.4%) Canonicalizer
0.0005 ( 6.2%) VerifierPass 0.0005 ( 6.2%) VerifierPass
0.0005 ( 5.8%) VerifierPass 0.0005 ( 5.8%) VerifierPass
0.0014 ( 17.2%) LLVMLoweringPass 0.0014 ( 17.2%) LLVMLoweringPass
0.0005 ( 6.2%) VerifierPass 0.0005 ( 6.2%) VerifierPass
0.0082 (100.0%) Total 0.0082 (100.0%) Total
``` ```
##### Multi-threaded Pass Timing ##### Multi-threaded Pass Timing
When multi-threading is enabled in the pass manager the meaning of the display When multi-threading is enabled in the pass manager the meaning of the display
slightly changes. First, a new timing column is added, `User Time`, that slightly changes. First, a new timing column is added, `User Time`, that
displays the total time spent across all threads. Secondly, the `Wall Time` displays the total time spent across all threads. Secondly, the `Wall Time`
column displays the longest individual time spent amongst all of the threads. column displays the longest individual time spent amongst all of the threads.
This means that the `Wall Time` column will continue to give an indicator on the This means that the `Wall Time` column will continue to give an indicator on the
perceived time, or clock time, whereas the `User Time` will display the total perceived time, or clock time, whereas the `User Time` will display the total
cpu time. cpu time.
```shell ```shell
$ mlir-opt foo.mlir -pass-pipeline='builtin.func(cse,canonicalize)' -convert-func-to-llvm -mlir-timing $ mlir-opt foo.mlir -pass-pipeline='func.func(cse,canonicalize)' -convert-func-to-llvm -mlir-timing
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
... Pass execution timing report ... ... Pass execution timing report ...
===-------------------------------------------------------------------------=== ===-------------------------------------------------------------------------===
Total Execution Time: 0.0078 seconds Total Execution Time: 0.0078 seconds
---User Time--- ---Wall Time--- --- Name --- ---User Time--- ---Wall Time--- --- Name ---
0.0177 ( 88.5%) 0.0057 ( 71.3%) 'builtin.func' Pipeline 0.0177 ( 88.5%) 0.0057 ( 71.3%) 'func.func' Pipeline
0.0044 ( 22.0%) 0.0015 ( 18.9%) CSE 0.0044 ( 22.0%) 0.0015 ( 18.9%) CSE
0.0029 ( 14.5%) 0.0012 ( 15.2%) (A) DominanceInfo 0.0029 ( 14.5%) 0.0012 ( 15.2%) (A) DominanceInfo
0.0038 ( 18.9%) 0.0015 ( 18.7%) VerifierPass 0.0038 ( 18.9%) 0.0015 ( 18.7%) VerifierPass
0.0089 ( 44.6%) 0.0025 ( 31.1%) Canonicalizer 0.0089 ( 44.6%) 0.0025 ( 31.1%) Canonicalizer
0.0006 ( 3.0%) 0.0002 ( 2.6%) VerifierPass 0.0006 ( 3.0%) 0.0002 ( 2.6%) VerifierPass
0.0004 ( 2.2%) 0.0004 ( 5.4%) VerifierPass 0.0004 ( 2.2%) 0.0004 ( 5.4%) VerifierPass
0.0013 ( 6.5%) 0.0013 ( 16.3%) LLVMLoweringPass 0.0013 ( 6.5%) 0.0013 ( 16.3%) LLVMLoweringPass
0.0006 ( 2.8%) 0.0006 ( 7.0%) VerifierPass 0.0006 ( 2.8%) 0.0006 ( 7.0%) VerifierPass
Show All 11 Lines
this instrumentation: this instrumentation:
* `print-ir-before=(comma-separated-pass-list)` * `print-ir-before=(comma-separated-pass-list)`
* Print the IR before each of the passes provided within the pass list. * Print the IR before each of the passes provided within the pass list.
* `print-ir-before-all` * `print-ir-before-all`
* Print the IR before every pass in the pipeline. * Print the IR before every pass in the pipeline.
```shell ```shell
$ mlir-opt foo.mlir -pass-pipeline='builtin.func(cse)' -print-ir-before=cse $ mlir-opt foo.mlir -pass-pipeline='func.func(cse)' -print-ir-before=cse
*** IR Dump Before CSE *** *** IR Dump Before CSE ***
func @simple_constant() -> (i32, i32) { func @simple_constant() -> (i32, i32) {
%c1_i32 = arith.constant 1 : i32 %c1_i32 = arith.constant 1 : i32
%c1_i32_0 = arith.constant 1 : i32 %c1_i32_0 = arith.constant 1 : i32
return %c1_i32, %c1_i32_0 : i32, i32 return %c1_i32, %c1_i32_0 : i32, i32
} }
``` ```
* `print-ir-after=(comma-separated-pass-list)` * `print-ir-after=(comma-separated-pass-list)`
* Print the IR after each of the passes provided within the pass list. * Print the IR after each of the passes provided within the pass list.
* `print-ir-after-all` * `print-ir-after-all`
* Print the IR after every pass in the pipeline. * Print the IR after every pass in the pipeline.
```shell ```shell
$ mlir-opt foo.mlir -pass-pipeline='builtin.func(cse)' -print-ir-after=cse $ mlir-opt foo.mlir -pass-pipeline='func.func(cse)' -print-ir-after=cse
*** IR Dump After CSE *** *** IR Dump After CSE ***
func @simple_constant() -> (i32, i32) { func @simple_constant() -> (i32, i32) {
%c1_i32 = arith.constant 1 : i32 %c1_i32 = arith.constant 1 : i32
return %c1_i32, %c1_i32 : i32, i32 return %c1_i32, %c1_i32 : i32, i32
} }
``` ```
* `print-ir-after-change` * `print-ir-after-change`
* Only print the IR after a pass if the pass mutated the IR. This helps to * Only print the IR after a pass if the pass mutated the IR. This helps to
reduce the number of IR dumps for "uninteresting" passes. reduce the number of IR dumps for "uninteresting" passes.
* Note: Changes are detected by comparing a hash of the operation before * Note: Changes are detected by comparing a hash of the operation before
and after the pass. This adds additional run-time to compute the hash of and after the pass. This adds additional run-time to compute the hash of
the IR, and in some rare cases may result in false-positives depending the IR, and in some rare cases may result in false-positives depending
on the collision rate of the hash algorithm used. on the collision rate of the hash algorithm used.
* Note: This option should be used in unison with one of the other * Note: This option should be used in unison with one of the other
'print-ir-after' options above, as this option alone does not enable 'print-ir-after' options above, as this option alone does not enable
printing. printing.
```shell ```shell
$ mlir-opt foo.mlir -pass-pipeline='builtin.func(cse,cse)' -print-ir-after=cse -print-ir-after-change $ mlir-opt foo.mlir -pass-pipeline='func.func(cse,cse)' -print-ir-after=cse -print-ir-after-change
*** IR Dump After CSE *** *** IR Dump After CSE ***
func @simple_constant() -> (i32, i32) { func @simple_constant() -> (i32, i32) {
%c1_i32 = arith.constant 1 : i32 %c1_i32 = arith.constant 1 : i32
return %c1_i32, %c1_i32 : i32, i32 return %c1_i32, %c1_i32 : i32, i32
} }
``` ```
* `print-ir-after-failure` * `print-ir-after-failure`
* Only print IR after a pass failure. * Only print IR after a pass failure.
* This option should *not* be used with the other `print-ir-after` flags * This option should *not* be used with the other `print-ir-after` flags
above. above.
```shell ```shell
$ mlir-opt foo.mlir -pass-pipeline='builtin.func(cse,bad-pass)' -print-ir-failure $ mlir-opt foo.mlir -pass-pipeline='func.func(cse,bad-pass)' -print-ir-failure
*** IR Dump After BadPass Failed *** *** IR Dump After BadPass Failed ***
func @simple_constant() -> (i32, i32) { func @simple_constant() -> (i32, i32) {
%c1_i32 = arith.constant 1 : i32 %c1_i32 = arith.constant 1 : i32
return %c1_i32, %c1_i32 : i32, i32 return %c1_i32, %c1_i32 : i32, i32
} }
``` ```
* `print-ir-module-scope` * `print-ir-module-scope`
* Always print the top-level module operation, regardless of pass type or * Always print the top-level module operation, regardless of pass type or
operation nesting level. operation nesting level.
* Note: Printing at module scope should only be used when multi-threading * Note: Printing at module scope should only be used when multi-threading
is disabled(`-mlir-disable-threading`) is disabled(`-mlir-disable-threading`)
```shell ```shell
$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='builtin.func(cse)' -print-ir-after=cse -print-ir-module-scope $ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='func.func(cse)' -print-ir-after=cse -print-ir-module-scope
*** IR Dump After CSE *** ('builtin.func' operation: @bar) *** IR Dump After CSE *** ('func.func' operation: @bar)
func @bar(%arg0: f32, %arg1: f32) -> f32 { func @bar(%arg0: f32, %arg1: f32) -> f32 {
... ...
} }
func @simple_constant() -> (i32, i32) { func @simple_constant() -> (i32, i32) {
%c1_i32 = arith.constant 1 : i32 %c1_i32 = arith.constant 1 : i32
%c1_i32_0 = arith.constant 1 : i32 %c1_i32_0 = arith.constant 1 : i32
return %c1_i32, %c1_i32_0 : i32, i32 return %c1_i32, %c1_i32_0 : i32, i32
} }
*** IR Dump After CSE *** ('builtin.func' operation: @simple_constant) *** IR Dump After CSE *** ('func.func' operation: @simple_constant)
func @bar(%arg0: f32, %arg1: f32) -> f32 { func @bar(%arg0: f32, %arg1: f32) -> f32 {
... ...
} }
func @simple_constant() -> (i32, i32) { func @simple_constant() -> (i32, i32) {
%c1_i32 = arith.constant 1 : i32 %c1_i32 = arith.constant 1 : i32
return %c1_i32, %c1_i32 : i32, i32 return %c1_i32, %c1_i32 : i32, i32
} }
``` ```
## Crash and Failure Reproduction ## Crash and Failure Reproduction
The [pass manager](#pass-manager) in MLIR contains a builtin mechanism to The [pass manager](#pass-manager) in MLIR contains a builtin mechanism to
generate reproducibles in the event of a crash, or a generate reproducibles in the event of a crash, or a
[pass failure](#pass-failure). This functionality can be enabled via [pass failure](#pass-failure). This functionality can be enabled via
`PassManager::enableCrashReproducerGeneration` or via the command line flag `PassManager::enableCrashReproducerGeneration` or via the command line flag
`pass-pipeline-crash-reproducer`. In either case, an argument is provided that `pass-pipeline-crash-reproducer`. In either case, an argument is provided that
corresponds to the output `.mlir` file name that the reproducible should be corresponds to the output `.mlir` file name that the reproducible should be
written to. The reproducible contains the configuration of the pass manager that written to. The reproducible contains the configuration of the pass manager that
was executing, as well as the initial IR before any passes were run. A potential was executing, as well as the initial IR before any passes were run. A potential
reproducible may have the form: reproducible may have the form:
```mlir ```mlir
// configuration: -pass-pipeline='builtin.func(cse,canonicalize),inline' -verify-each // configuration: -pass-pipeline='func.func(cse,canonicalize),inline' -verify-each
module { module {
func @foo() { func @foo() {
... ...
} }
} }
``` ```
Show All 18 Lines
Note: Local reproducer generation requires that multi-threading is Note: Local reproducer generation requires that multi-threading is
disabled(`-mlir-disable-threading`) disabled(`-mlir-disable-threading`)
For example, if the failure in the previous example came from `canonicalize`, For example, if the failure in the previous example came from `canonicalize`,
the following reproducer will be generated: the following reproducer will be generated:
```mlir ```mlir
// configuration: -pass-pipeline='builtin.func(canonicalize)' -verify-each -mlir-disable-threading // configuration: -pass-pipeline='func.func(canonicalize)' -verify-each -mlir-disable-threading
module { module {
func @foo() { func @foo() {
... ...
} }
} }
``` ```

mlir/docs/SymbolsAndSymbolTables.md

Show All 25 Lines
## Symbol ## Symbol
A `Symbol` is a named operation that resides immediately within a region that A `Symbol` is a named operation that resides immediately within a region that
defines a [`SymbolTable`](#symbol-table). The name of a symbol *must* be unique defines a [`SymbolTable`](#symbol-table). The name of a symbol *must* be unique
within the parent `SymbolTable`. This name is semantically similarly to an SSA within the parent `SymbolTable`. This name is semantically similarly to an SSA
result value, and may be referred to by other operations to provide a symbolic result value, and may be referred to by other operations to provide a symbolic
link, or use, to the symbol. An example of a `Symbol` operation is link, or use, to the symbol. An example of a `Symbol` operation is
[`builtin.func`](Dialects/Builtin.md/#func-mlirfuncop). `builtin.func` defines a [`func.func`](Dialects/Builtin.md/#func-mlirfuncop). `func.func` defines a
symbol name, which is [referred to](#referencing-a-symbol) by operations like symbol name, which is [referred to](#referencing-a-symbol) by operations like
[`func.call`](Dialects/Func.md/#funccall-callop). [`func.call`](Dialects/Func.md/#funccall-callop).
### Defining or declaring a Symbol ### Defining or declaring a Symbol
A `Symbol` operation should use the `SymbolOpInterface` interface to provide the A `Symbol` operation should use the `SymbolOpInterface` interface to provide the
necessary verification and accessors; it also supports operations, such as necessary verification and accessors; it also supports operations, such as
`builtin.module`, that conditionally define a symbol. `Symbol`s must have the `builtin.module`, that conditionally define a symbol. `Symbol`s must have the
Show All 29 Lines
within a symbol table. It may optionally contain a set of nested references that within a symbol table. It may optionally contain a set of nested references that
further resolve to a symbol nested within a different symbol table. When further resolve to a symbol nested within a different symbol table. When
resolving a nested reference, each non-leaf reference must refer to a symbol resolving a nested reference, each non-leaf reference must refer to a symbol
operation that is also a [symbol table](#symbol-table). operation that is also a [symbol table](#symbol-table).
Below is an example of how an operation can reference a symbol operation: Below is an example of how an operation can reference a symbol operation:
```mlir ```mlir
// This `builtin.func` operation defines a symbol named `symbol`. // This `func.func` operation defines a symbol named `symbol`.
func @symbol() func @symbol()
// Our `foo.user` operation contains a SymbolRefAttr with the name of the // Our `foo.user` operation contains a SymbolRefAttr with the name of the
// `symbol` func. // `symbol` func.
"foo.user"() {uses = [@symbol]} : () -> () "foo.user"() {uses = [@symbol]} : () -> ()
// Symbol references resolve to the nearest parent operation that defines a // Symbol references resolve to the nearest parent operation that defines a
// symbol table, so we can have references with arbitrary nesting levels. // symbol table, so we can have references with arbitrary nesting levels.
Show All 12 Linesmodule {
// Error. We resolve references with respect to the closest parent operation // Error. We resolve references with respect to the closest parent operation
// that defines a symbol table, so this reference can't be resolved. // that defines a symbol table, so this reference can't be resolved.
"foo.user"() {uses = [@symbol]} : () -> () "foo.user"() {uses = [@symbol]} : () -> ()
} }
// Here we define another nested symbol table, except this time it also defines // Here we define another nested symbol table, except this time it also defines
// a symbol. // a symbol.
module @module_symbol { module @module_symbol {
// This `builtin.func` operation defines a symbol named `nested_symbol`. // This `func.func` operation defines a symbol named `nested_symbol`.
func @nested_symbol() func @nested_symbol()
} }
// Our `foo.user` operation may refer to the nested symbol, by resolving through // Our `foo.user` operation may refer to the nested symbol, by resolving through
// the parent. // the parent.
"foo.user"() {uses = [@module_symbol::@nested_symbol]} : () -> () "foo.user"() {uses = [@module_symbol::@nested_symbol]} : () -> ()
``` ```
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

mlir/docs/TargetLLVMIR.md

Show First 20 Lines • Show All 342 Lines • ▼ Show 20 Lines
The default calling convention converts `memref`-typed function arguments to The default calling convention converts `memref`-typed function arguments to
LLVM dialect literal structs LLVM dialect literal structs
[defined above](TargetLLVMIR.md#ranked-memref-types) before unbundling them into [defined above](TargetLLVMIR.md#ranked-memref-types) before unbundling them into
individual scalar arguments. individual scalar arguments.
Examples: Examples:
This convention is implemented in the conversion of `builtin.func` and `func.call` to This convention is implemented in the conversion of `func.func` and `func.call` to
the LLVM dialect, with the former unpacking the descriptor into a set of the LLVM dialect, with the former unpacking the descriptor into a set of
individual values and the latter packing those values back into a descriptor so individual values and the latter packing those values back into a descriptor so
as to make it transparently usable by other operations. Conversions from other as to make it transparently usable by other operations. Conversions from other
dialects should take this convention into account. dialects should take this convention into account.
This specific convention is motivated by the necessity to specify alignment and This specific convention is motivated by the necessity to specify alignment and
aliasing attributes on the raw pointers underpinning the memref. aliasing attributes on the raw pointers underpinning the memref.
▲ Show 20 Lines • Show All 539 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Affine/LoopUtils.h

Show All 16 Lines
#include "mlir/IR/Block.h" #include "mlir/IR/Block.h"
#include "mlir/Support/LLVM.h" #include "mlir/Support/LLVM.h"
#include "mlir/Support/LogicalResult.h" #include "mlir/Support/LogicalResult.h"
namespace mlir { namespace mlir {
class AffineForOp; class AffineForOp;
class AffineMap; class AffineMap;
class FuncOp;
class LoopLikeOpInterface; class LoopLikeOpInterface;
struct MemRefRegion; struct MemRefRegion;
class OpBuilder; class OpBuilder;
class Value; class Value;
class ValueRange; class ValueRange;
namespace func {
class FuncOp;
} // namespace func
namespace scf { namespace scf {
class ForOp; class ForOp;
class ParallelOp; class ParallelOp;
} // namespace scf } // namespace scf
/// Unrolls this for operation completely if the trip count is known to be /// Unrolls this for operation completely if the trip count is known to be
/// constant. Returns failure otherwise. /// constant. Returns failure otherwise.
LogicalResult loopUnrollFull(AffineForOp forOp); LogicalResult loopUnrollFull(AffineForOp forOp);
Show All 34 LinesLogicalResult loopUnrollJamUpToFactor(AffineForOp forOp,
uint64_t unrollJamFactor); uint64_t unrollJamFactor);
/// Promotes the loop body of a AffineForOp to its containing block if the loop /// Promotes the loop body of a AffineForOp to its containing block if the loop
/// was known to have a single iteration. /// was known to have a single iteration.
LogicalResult promoteIfSingleIteration(AffineForOp forOp); LogicalResult promoteIfSingleIteration(AffineForOp forOp);
/// Promotes all single iteration AffineForOp's in the Function, i.e., moves /// Promotes all single iteration AffineForOp's in the Function, i.e., moves
/// their body into the containing Block. /// their body into the containing Block.
void promoteSingleIterationLoops(FuncOp f); void promoteSingleIterationLoops(func::FuncOp f);
/// Skew the operations in an affine.for's body with the specified /// Skew the operations in an affine.for's body with the specified
/// operation-wise shifts. The shifts are with respect to the original execution /// operation-wise shifts. The shifts are with respect to the original execution
/// order, and are multiplied by the loop 'step' before being applied. If /// order, and are multiplied by the loop 'step' before being applied. If
/// `unrollPrologueEpilogue` is set, fully unroll the prologue and epilogue /// `unrollPrologueEpilogue` is set, fully unroll the prologue and epilogue
/// loops when possible. /// loops when possible.
LogicalResult affineForOpBodySkew(AffineForOp forOp, ArrayRef<uint64_t> shifts, LogicalResult affineForOpBodySkew(AffineForOp forOp, ArrayRef<uint64_t> shifts,
bool unrollPrologueEpilogue = false); bool unrollPrologueEpilogue = false);
/// Identify valid and profitable bands of loops to tile. This is currently just /// Identify valid and profitable bands of loops to tile. This is currently just
/// a temporary placeholder to test the mechanics of tiled code generation. /// a temporary placeholder to test the mechanics of tiled code generation.
/// Returns all maximal outermost perfect loop nests to tile. /// Returns all maximal outermost perfect loop nests to tile.
void getTileableBands(FuncOp f, void getTileableBands(func::FuncOp f,
std::vector<SmallVector<AffineForOp, 6>> *bands); std::vector<SmallVector<AffineForOp, 6>> *bands);
/// Tiles the specified band of perfectly nested loops creating tile-space loops /// Tiles the specified band of perfectly nested loops creating tile-space loops
/// and intra-tile loops. A band is a contiguous set of loops. /// and intra-tile loops. A band is a contiguous set of loops.
LogicalResult LogicalResult
tilePerfectlyNested(MutableArrayRef<AffineForOp> input, tilePerfectlyNested(MutableArrayRef<AffineForOp> input,
ArrayRef<unsigned> tileSizes, ArrayRef<unsigned> tileSizes,
SmallVectorImpl<AffineForOp> *tiledNest = nullptr); SmallVectorImpl<AffineForOp> *tiledNest = nullptr);
▲ Show 20 Lines • Show All 150 Lines • ▼ Show 20 Lines
/// scf.for %i = %lb + %step * (threadIdx.x + blockIdx.x * blockDim.x) /// scf.for %i = %lb + %step * (threadIdx.x + blockIdx.x * blockDim.x)
/// to %ub step %gridDim.x * blockDim.x * %step { /// to %ub step %gridDim.x * blockDim.x * %step {
/// ... /// ...
/// } /// }
/// ``` /// ```
void mapLoopToProcessorIds(scf::ForOp forOp, ArrayRef<Value> processorId, void mapLoopToProcessorIds(scf::ForOp forOp, ArrayRef<Value> processorId,
ArrayRef<Value> numProcessors); ArrayRef<Value> numProcessors);
/// Gathers all AffineForOps in 'builtin.func' grouped by loop depth. /// Gathers all AffineForOps in 'func.func' grouped by loop depth.
void gatherLoops(FuncOp func, void gatherLoops(func::FuncOp func,
std::vector<SmallVector<AffineForOp, 2>> &depthToLoops); std::vector<SmallVector<AffineForOp, 2>> &depthToLoops);
/// Creates an AffineForOp while ensuring that the lower and upper bounds are /// Creates an AffineForOp while ensuring that the lower and upper bounds are
/// canonicalized, i.e., unused and duplicate operands are removed, any constant /// canonicalized, i.e., unused and duplicate operands are removed, any constant
/// operands propagated/folded in, and duplicate bound maps dropped. /// operands propagated/folded in, and duplicate bound maps dropped.
AffineForOp createCanonicalizedAffineForOp(OpBuilder b, Location loc, AffineForOp createCanonicalizedAffineForOp(OpBuilder b, Location loc,
ValueRange lbOperands, ValueRange lbOperands,
AffineMap lbMap, AffineMap lbMap,
Show All 20 Lines

mlir/include/mlir/Dialect/Affine/Passes.h

Show All 12 Lines
#ifndef MLIR_DIALECT_AFFINE_PASSES_H #ifndef MLIR_DIALECT_AFFINE_PASSES_H
#define MLIR_DIALECT_AFFINE_PASSES_H #define MLIR_DIALECT_AFFINE_PASSES_H
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include <limits> #include <limits>
namespace mlir { namespace mlir {
namespace func {
class FuncOp;
} // namespace func
class AffineForOp; class AffineForOp;
/// Fusion mode to attempt. The default mode `Greedy` does both /// Fusion mode to attempt. The default mode `Greedy` does both
/// producer-consumer and sibling fusion. /// producer-consumer and sibling fusion.
enum FusionMode { Greedy, ProducerConsumer, Sibling }; enum FusionMode { Greedy, ProducerConsumer, Sibling };
/// Creates a simplification pass for affine structures (maps and sets). In /// Creates a simplification pass for affine structures (maps and sets). In
/// addition, this pass also normalizes memrefs to have the trivial (identity) /// addition, this pass also normalizes memrefs to have the trivial (identity)
/// layout map. /// layout map.
std::unique_ptr<OperationPass<FuncOp>> createSimplifyAffineStructuresPass(); std::unique_ptr<OperationPass<func::FuncOp>>
createSimplifyAffineStructuresPass();
/// Creates a loop invariant code motion pass that hoists loop invariant /// Creates a loop invariant code motion pass that hoists loop invariant
/// operations out of affine loops. /// operations out of affine loops.
std::unique_ptr<OperationPass<FuncOp>> std::unique_ptr<OperationPass<func::FuncOp>>
createAffineLoopInvariantCodeMotionPass(); createAffineLoopInvariantCodeMotionPass();
/// Creates a pass to convert all parallel affine.for's into 1-d affine.parallel /// Creates a pass to convert all parallel affine.for's into 1-d affine.parallel
/// ops. /// ops.
std::unique_ptr<OperationPass<FuncOp>> createAffineParallelizePass(); std::unique_ptr<OperationPass<func::FuncOp>> createAffineParallelizePass();
/// Apply normalization transformations to affine loop-like ops. /// Apply normalization transformations to affine loop-like ops.
std::unique_ptr<OperationPass<FuncOp>> createAffineLoopNormalizePass(); std::unique_ptr<OperationPass<func::FuncOp>> createAffineLoopNormalizePass();
/// Performs packing (or explicit copying) of accessed memref regions into /// Performs packing (or explicit copying) of accessed memref regions into
/// buffers in the specified faster memory space through either pointwise copies /// buffers in the specified faster memory space through either pointwise copies
/// or DMA operations. /// or DMA operations.
std::unique_ptr<OperationPass<FuncOp>> createAffineDataCopyGenerationPass( std::unique_ptr<OperationPass<func::FuncOp>> createAffineDataCopyGenerationPass(
unsigned slowMemorySpace, unsigned fastMemorySpace, unsigned slowMemorySpace, unsigned fastMemorySpace,
unsigned tagMemorySpace = 0, int minDmaTransferSize = 1024, unsigned tagMemorySpace = 0, int minDmaTransferSize = 1024,
uint64_t fastMemCapacityBytes = std::numeric_limits<uint64_t>::max()); uint64_t fastMemCapacityBytes = std::numeric_limits<uint64_t>::max());
/// Overload relying on pass options for initialization. /// Overload relying on pass options for initialization.
std::unique_ptr<OperationPass<FuncOp>> createAffineDataCopyGenerationPass(); std::unique_ptr<OperationPass<func::FuncOp>>
createAffineDataCopyGenerationPass();
/// Creates a pass to replace affine memref accesses by scalars using store to /// Creates a pass to replace affine memref accesses by scalars using store to
/// load forwarding and redundant load elimination; consequently also eliminate /// load forwarding and redundant load elimination; consequently also eliminate
/// dead allocs. /// dead allocs.
std::unique_ptr<OperationPass<FuncOp>> createAffineScalarReplacementPass(); std::unique_ptr<OperationPass<func::FuncOp>>
createAffineScalarReplacementPass();
/// Creates a pass that transforms perfectly nested loops with independent /// Creates a pass that transforms perfectly nested loops with independent
/// bounds into a single loop. /// bounds into a single loop.
std::unique_ptr<OperationPass<FuncOp>> createLoopCoalescingPass(); std::unique_ptr<OperationPass<func::FuncOp>> createLoopCoalescingPass();
/// Creates a loop fusion pass which fuses loops according to type of fusion /// Creates a loop fusion pass which fuses loops according to type of fusion
/// specified in `fusionMode`. Buffers of size less than or equal to /// specified in `fusionMode`. Buffers of size less than or equal to
/// `localBufSizeThreshold` are promoted to memory space `fastMemorySpace`. /// `localBufSizeThreshold` are promoted to memory space `fastMemorySpace`.
std::unique_ptr<OperationPass<FuncOp>> std::unique_ptr<OperationPass<func::FuncOp>>
createLoopFusionPass(unsigned fastMemorySpace = 0, createLoopFusionPass(unsigned fastMemorySpace = 0,
uint64_t localBufSizeThreshold = 0, uint64_t localBufSizeThreshold = 0,
bool maximalFusion = false, bool maximalFusion = false,
enum FusionMode fusionMode = FusionMode::Greedy); enum FusionMode fusionMode = FusionMode::Greedy);
/// Creates a pass to perform tiling on loop nests. /// Creates a pass to perform tiling on loop nests.
std::unique_ptr<OperationPass<FuncOp>> std::unique_ptr<OperationPass<func::FuncOp>>
createLoopTilingPass(uint64_t cacheSizeBytes); createLoopTilingPass(uint64_t cacheSizeBytes);
/// Overload relying on pass options for initialization. /// Overload relying on pass options for initialization.
std::unique_ptr<OperationPass<FuncOp>> createLoopTilingPass(); std::unique_ptr<OperationPass<func::FuncOp>> createLoopTilingPass();
/// Creates a loop unrolling pass with the provided parameters. /// Creates a loop unrolling pass with the provided parameters.
/// 'getUnrollFactor' is a function callback for clients to supply a function /// 'getUnrollFactor' is a function callback for clients to supply a function
/// that computes an unroll factor - the callback takes precedence over unroll /// that computes an unroll factor - the callback takes precedence over unroll
/// factors supplied through other means. If -1 is passed as the unrollFactor /// factors supplied through other means. If -1 is passed as the unrollFactor
/// and no callback is provided, anything passed from the command-line (if at /// and no callback is provided, anything passed from the command-line (if at
/// all) or the default unroll factor is used (LoopUnroll:kDefaultUnrollFactor). /// all) or the default unroll factor is used (LoopUnroll:kDefaultUnrollFactor).
std::unique_ptr<OperationPass<FuncOp>> createLoopUnrollPass( std::unique_ptr<OperationPass<func::FuncOp>> createLoopUnrollPass(
int unrollFactor = -1, bool unrollUpToFactor = false, int unrollFactor = -1, bool unrollUpToFactor = false,
bool unrollFull = false, bool unrollFull = false,
const std::function<unsigned(AffineForOp)> &getUnrollFactor = nullptr); const std::function<unsigned(AffineForOp)> &getUnrollFactor = nullptr);
/// Creates a loop unroll jam pass to unroll jam by the specified factor. A /// Creates a loop unroll jam pass to unroll jam by the specified factor. A
/// factor of -1 lets the pass use the default factor or the one on the command /// factor of -1 lets the pass use the default factor or the one on the command
/// line if provided. /// line if provided.
std::unique_ptr<OperationPass<FuncOp>> std::unique_ptr<OperationPass<func::FuncOp>>
createLoopUnrollAndJamPass(int unrollJamFactor = -1); createLoopUnrollAndJamPass(int unrollJamFactor = -1);
/// Creates a pass to pipeline explicit movement of data across levels of the /// Creates a pass to pipeline explicit movement of data across levels of the
/// memory hierarchy. /// memory hierarchy.
std::unique_ptr<OperationPass<FuncOp>> createPipelineDataTransferPass(); std::unique_ptr<OperationPass<func::FuncOp>> createPipelineDataTransferPass();
/// Creates a pass to vectorize loops, operations and data types using a /// Creates a pass to vectorize loops, operations and data types using a
/// target-independent, n-D super-vector abstraction. /// target-independent, n-D super-vector abstraction.
std::unique_ptr<OperationPass<FuncOp>> std::unique_ptr<OperationPass<func::FuncOp>>
createSuperVectorizePass(ArrayRef<int64_t> virtualVectorSize); createSuperVectorizePass(ArrayRef<int64_t> virtualVectorSize);
/// Overload relying on pass options for initialization. /// Overload relying on pass options for initialization.
std::unique_ptr<OperationPass<FuncOp>> createSuperVectorizePass(); std::unique_ptr<OperationPass<func::FuncOp>> createSuperVectorizePass();
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Registration // Registration
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Generate the code for registering passes. /// Generate the code for registering passes.
#define GEN_PASS_REGISTRATION #define GEN_PASS_REGISTRATION
#include "mlir/Dialect/Affine/Passes.h.inc" #include "mlir/Dialect/Affine/Passes.h.inc"
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_AFFINE_PASSES_H #endif // MLIR_DIALECT_AFFINE_PASSES_H

mlir/include/mlir/Dialect/Affine/Utils.h

Show All 15 Lines
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h" #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
namespace mlir { namespace mlir {
class AffineForOp; class AffineForOp;
class AffineIfOp; class AffineIfOp;
class AffineParallelOp; class AffineParallelOp;
class DominanceInfo; class DominanceInfo;
class FuncOp;
class Operation; class Operation;
class PostDominanceInfo; class PostDominanceInfo;
namespace func {
class FuncOp;
} // namespace func
namespace memref { namespace memref {
class AllocOp; class AllocOp;
} // namespace memref } // namespace memref
struct LogicalResult; struct LogicalResult;
using ReductionLoopMap = DenseMap<Operation *, SmallVector<LoopReduction, 2>>; using ReductionLoopMap = DenseMap<Operation *, SmallVector<LoopReduction, 2>>;
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Linesstruct VectorizationStrategy {
// Maps loops that implement vectorizable reductions to the corresponding // Maps loops that implement vectorizable reductions to the corresponding
// reduction descriptors. // reduction descriptors.
ReductionLoopMap reductionLoops; ReductionLoopMap reductionLoops;
}; };
/// Replace affine store and load accesses by scalars by forwarding stores to /// Replace affine store and load accesses by scalars by forwarding stores to
/// loads and eliminate invariant affine loads; consequently, eliminate dead /// loads and eliminate invariant affine loads; consequently, eliminate dead
/// allocs. /// allocs.
void affineScalarReplace(FuncOp f, DominanceInfo &domInfo, void affineScalarReplace(func::FuncOp f, DominanceInfo &domInfo,
PostDominanceInfo &postDomInfo); PostDominanceInfo &postDomInfo);
/// Vectorizes affine loops in 'loops' using the n-D vectorization factors in /// Vectorizes affine loops in 'loops' using the n-D vectorization factors in
/// 'vectorSizes'. By default, each vectorization factor is applied /// 'vectorSizes'. By default, each vectorization factor is applied
/// inner-to-outer to the loops of each loop nest. 'fastestVaryingPattern' can /// inner-to-outer to the loops of each loop nest. 'fastestVaryingPattern' can
/// be optionally used to provide a different loop vectorization order. /// be optionally used to provide a different loop vectorization order.
/// If `reductionLoops` is not empty, the given reduction loops may be /// If `reductionLoops` is not empty, the given reduction loops may be
/// vectorized along the reduction dimension. /// vectorized along the reduction dimension.
▲ Show 20 Lines • Show All 199 Lines • Show Last 20 Lines

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

#ifndef MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_PASSES_H #ifndef MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_PASSES_H
#define MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_PASSES_H #define MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_PASSES_H
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
namespace func {
class FuncOp;
} // namespace func
namespace bufferization { namespace bufferization {
struct OneShotBufferizationOptions; struct OneShotBufferizationOptions;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Passes // Passes
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Creates an instance of the BufferDeallocation pass to free all allocated /// Creates an instance of the BufferDeallocation pass to free all allocated
Show All 11 Lines
/// reallocations inside of loops. /// reallocations inside of loops.
std::unique_ptr<Pass> createBufferLoopHoistingPass(); std::unique_ptr<Pass> createBufferLoopHoistingPass();
/// Creates a pass that converts memref function results to out-params. /// Creates a pass that converts memref function results to out-params.
std::unique_ptr<Pass> createBufferResultsToOutParamsPass(); std::unique_ptr<Pass> createBufferResultsToOutParamsPass();
/// Creates a pass that finalizes a partial bufferization by removing remaining /// Creates a pass that finalizes a partial bufferization by removing remaining
/// bufferization.to_tensor and bufferization.to_memref operations. /// bufferization.to_tensor and bufferization.to_memref operations.
std::unique_ptr<OperationPass<FuncOp>> createFinalizingBufferizePass(); std::unique_ptr<OperationPass<func::FuncOp>> createFinalizingBufferizePass();
/// Create a pass that bufferizes all ops that implement BufferizableOpInterface /// Create a pass that bufferizes all ops that implement BufferizableOpInterface
/// with One-Shot Bufferize. /// with One-Shot Bufferize.
std::unique_ptr<Pass> createOneShotBufferizePass(); std::unique_ptr<Pass> createOneShotBufferizePass();
/// Create a pass that bufferizes all ops that implement BufferizableOpInterface /// Create a pass that bufferizes all ops that implement BufferizableOpInterface
/// with One-Shot Bufferize and the specified bufferization options. /// with One-Shot Bufferize and the specified bufferization options.
std::unique_ptr<Pass> std::unique_ptr<Pass>
Show All 29 Lines

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

//===-- Passes.td - Bufferization passes definition file ---*- tablegen -*-===// //===-- Passes.td - Bufferization passes definition file ---*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_PASSES #ifndef MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_PASSES
#define MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_PASSES #define MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_PASSES
include "mlir/Pass/PassBase.td" include "mlir/Pass/PassBase.td"
def BufferDeallocation : Pass<"buffer-deallocation", "FuncOp"> { def BufferDeallocation : Pass<"buffer-deallocation", "func::FuncOp"> {
let summary = "Adds all required dealloc operations for all allocations in " let summary = "Adds all required dealloc operations for all allocations in "
"the input program"; "the input program";
let description = [{ let description = [{
This pass implements an algorithm to automatically introduce all required This pass implements an algorithm to automatically introduce all required
deallocation operations for all buffers in the input program. This ensures deallocation operations for all buffers in the input program. This ensures
that the resulting program does not have any memory leaks. that the resulting program does not have any memory leaks.
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines let description = [{
} }
``` ```
}]; }];
let constructor = "mlir::bufferization::createBufferDeallocationPass()"; let constructor = "mlir::bufferization::createBufferDeallocationPass()";
} }
def BufferHoisting : Pass<"buffer-hoisting", "FuncOp"> { def BufferHoisting : Pass<"buffer-hoisting", "func::FuncOp"> {
let summary = "Optimizes placement of allocation operations by moving them " let summary = "Optimizes placement of allocation operations by moving them "
"into common dominators and out of nested regions"; "into common dominators and out of nested regions";
let description = [{ let description = [{
This pass implements an approach to aggressively move allocations upwards This pass implements an approach to aggressively move allocations upwards
into common dominators and out of nested regions. into common dominators and out of nested regions.
}]; }];
let constructor = "mlir::bufferization::createBufferHoistingPass()"; let constructor = "mlir::bufferization::createBufferHoistingPass()";
} }
def BufferLoopHoisting : Pass<"buffer-loop-hoisting", "FuncOp"> { def BufferLoopHoisting : Pass<"buffer-loop-hoisting", "func::FuncOp"> {
let summary = "Optimizes placement of allocation operations by moving them " let summary = "Optimizes placement of allocation operations by moving them "
"out of loop nests"; "out of loop nests";
let description = [{ let description = [{
This pass implements an approach to aggressively move allocations upwards This pass implements an approach to aggressively move allocations upwards
out of loop nests. It does not move allocations into common dominators. out of loop nests. It does not move allocations into common dominators.
}]; }];
let constructor = "mlir::bufferization::createBufferLoopHoistingPass()"; let constructor = "mlir::bufferization::createBufferLoopHoistingPass()";
} }
Show All 18 Lines let description = [{
The main issue with this pass (and the out-param calling convention) is that The main issue with this pass (and the out-param calling convention) is that
buffers for results need to be allocated in the caller. This currently only buffers for results need to be allocated in the caller. This currently only
works for static shaped memrefs. works for static shaped memrefs.
}]; }];
let constructor = "mlir::bufferization::createBufferResultsToOutParamsPass()"; let constructor = "mlir::bufferization::createBufferResultsToOutParamsPass()";
let dependentDialects = ["memref::MemRefDialect"]; let dependentDialects = ["memref::MemRefDialect"];
} }
def FinalizingBufferize : Pass<"finalizing-bufferize", "FuncOp"> { def FinalizingBufferize : Pass<"finalizing-bufferize", "func::FuncOp"> {
let summary = "Finalize a partial bufferization"; let summary = "Finalize a partial bufferization";
let description = [{ let description = [{
A bufferize pass that finalizes a partial bufferization by removing A bufferize pass that finalizes a partial bufferization by removing
remaining `bufferization.to_tensor` and `bufferization.to_buffer` operations. remaining `bufferization.to_tensor` and `bufferization.to_buffer` operations.
The removal of those operations is only possible if the operations only The removal of those operations is only possible if the operations only
exist in pairs, i.e., all uses of `bufferization.to_tensor` operations are exist in pairs, i.e., all uses of `bufferization.to_tensor` operations are
`bufferization.to_buffer` operations. `bufferization.to_buffer` operations.
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines let options = [
Option<"printConflicts", "print-conflicts", "bool", Option<"printConflicts", "print-conflicts", "bool",
/*default=*/"false", /*default=*/"false",
"Test only: Annotate IR with RaW conflicts. Requires " "Test only: Annotate IR with RaW conflicts. Requires "
"test-analysis-only.">, "test-analysis-only.">,
]; ];
let constructor = "mlir::bufferization::createOneShotBufferizePass()"; let constructor = "mlir::bufferization::createOneShotBufferizePass()";
} }
def PromoteBuffersToStack : Pass<"promote-buffers-to-stack", "FuncOp"> { def PromoteBuffersToStack : Pass<"promote-buffers-to-stack", "func::FuncOp"> {
let summary = "Promotes heap-based allocations to automatically managed " let summary = "Promotes heap-based allocations to automatically managed "
"stack-based allocations"; "stack-based allocations";
let description = [{ let description = [{
This pass implements a simple algorithm to convert heap-based memory This pass implements a simple algorithm to convert heap-based memory
allocations to stack-based ones. It uses a built-in heuristic to decide allocations to stack-based ones. It uses a built-in heuristic to decide
whether it makes sense to convert an allocation. Furthermore, dynamic whether it makes sense to convert an allocation. Furthermore, dynamic
shaped buffers that are limited by the rank of the tensor can be shaped buffers that are limited by the rank of the tensor can be
converted. They are only transformed if they are considered to be small. converted. They are only transformed if they are considered to be small.
Show All 13 Lines

mlir/include/mlir/Dialect/Func/IR/FuncOps.h

//===- FuncOps.h - Func Dialect Operations ----------------------*- C++ -*-===// //===- FuncOps.h - Func Dialect 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_FUNC_IR_OPS_H #ifndef MLIR_DIALECT_FUNC_IR_OPS_H
#define MLIR_DIALECT_FUNC_IR_OPS_H #define MLIR_DIALECT_FUNC_IR_OPS_H
#include "mlir/Dialect/ControlFlow/IR/ControlFlow.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.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/FunctionInterfaces.h"
#include "mlir/IR/OpImplementation.h" #include "mlir/IR/OpImplementation.h"
#include "mlir/IR/SymbolTable.h"
#include "mlir/Interfaces/CallInterfaces.h" #include "mlir/Interfaces/CallInterfaces.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"
namespace mlir { namespace mlir {
class PatternRewriter; class PatternRewriter;
} // namespace mlir } // namespace mlir
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "mlir/Dialect/Func/IR/FuncOps.h.inc" #include "mlir/Dialect/Func/IR/FuncOps.h.inc"
#include "mlir/Dialect/Func/IR/FuncOpsDialect.h.inc" #include "mlir/Dialect/Func/IR/FuncOpsDialect.h.inc"
namespace mlir {
/// FIXME: This is a temporary using directive to ease the transition of FuncOp
/// to the Func dialect. This will be removed after all uses are updated.
using FuncOp = func::FuncOp;
} // namespace mlir
namespace llvm {
/// Allow stealing the low bits of FuncOp.
template <>
struct PointerLikeTypeTraits<mlir::func::FuncOp> {
static inline void *getAsVoidPointer(mlir::func::FuncOp val) {
return const_cast<void *>(val.getAsOpaquePointer());
}
static inline mlir::func::FuncOp getFromVoidPointer(void *p) {
return mlir::func::FuncOp::getFromOpaquePointer(p);
}
static constexpr int numLowBitsAvailable = 3;
};
} // namespace llvm
#endif // MLIR_DIALECT_FUNC_IR_OPS_H #endif // MLIR_DIALECT_FUNC_IR_OPS_H

mlir/include/mlir/Dialect/Func/IR/FuncOps.td

//===- FuncOps.td - Func operation definitions -------------*- tablegen -*-===// //===- FuncOps.td - Func operation definitions -------------*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_FUNC_IR_FUNCOPS_TD #ifndef MLIR_DIALECT_FUNC_IR_FUNCOPS_TD
#define MLIR_DIALECT_FUNC_IR_FUNCOPS_TD #define MLIR_DIALECT_FUNC_IR_FUNCOPS_TD
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/ControlFlowInterfaces.td" include "mlir/Interfaces/ControlFlowInterfaces.td"
include "mlir/IR/FunctionInterfaces.td"
include "mlir/Interfaces/InferTypeOpInterface.td" include "mlir/Interfaces/InferTypeOpInterface.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
def Func_Dialect : Dialect { def Func_Dialect : Dialect {
let name = "func"; let name = "func";
let cppNamespace = "::mlir::func"; let cppNamespace = "::mlir::func";
let dependentDialects = ["cf::ControlFlowDialect"]; let dependentDialects = ["cf::ControlFlowDialect"];
let hasConstantMaterializer = 1; let hasConstantMaterializer = 1;
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines let extraClassDeclaration = [{
static bool isBuildableWith(Attribute value, Type type); static bool isBuildableWith(Attribute value, Type type);
}]; }];
let hasFolder = 1; let hasFolder = 1;
let hasVerifier = 1; let hasVerifier = 1;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// FuncOp
//===----------------------------------------------------------------------===//
def FuncOp : Func_Op<"func", [
AffineScope, AutomaticAllocationScope, CallableOpInterface,
FunctionOpInterface, IsolatedFromAbove, Symbol
]> {
let summary = "An operation with a name containing a single `SSACFG` region";
let description = [{
Operations within the function cannot implicitly capture values defined
outside of the function, i.e. Functions are `IsolatedFromAbove`. All
external references must use function arguments or attributes that establish
a symbolic connection (e.g. symbols referenced by name via a string
attribute like SymbolRefAttr). An external function declaration (used when
referring to a function declared in some other module) has no body. While
the MLIR textual form provides a nice inline syntax for function arguments,
they are internally represented as “block arguments” to the first block in
the region.
Only dialect attribute names may be specified in the attribute dictionaries
for function arguments, results, or the function itself.
Example:
```mlir
// External function definitions.
func.func @abort()
func.func @scribble(i32, i64, memref<? x 128 x f32, #layout_map0>) -> f64
// A function that returns its argument twice:
func.func @count(%x: i64) -> (i64, i64)
attributes {fruit: "banana"} {
return %x, %x: i64, i64
}
// A function with an argument attribute
func.func @example_fn_arg(%x: i32 {swift.self = unit})
// A function with a result attribute
func.func @example_fn_result() -> (f64 {dialectName.attrName = 0 : i64})
// A function with an attribute
func.func @example_fn_attr() attributes {dialectName.attrName = false}
```
}];
let arguments = (ins SymbolNameAttr:$sym_name,
TypeAttrOf<FunctionType>:$type,
OptionalAttr<StrAttr>:$sym_visibility);
let regions = (region AnyRegion:$body);
let builders = [OpBuilder<(ins
"StringRef":$name, "FunctionType":$type,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs,
CArg<"ArrayRef<DictionaryAttr>", "{}">:$argAttrs)
>];
let extraClassDeclaration = [{
static FuncOp create(Location location, StringRef name, FunctionType type,
ArrayRef<NamedAttribute> attrs = {});
static FuncOp create(Location location, StringRef name, FunctionType type,
Operation::dialect_attr_range attrs);
static FuncOp create(Location location, StringRef name, FunctionType type,
ArrayRef<NamedAttribute> attrs,
ArrayRef<DictionaryAttr> argAttrs);
/// Create a deep copy of this function and all of its blocks, remapping any
/// operands that use values outside of the function using the map that is
/// provided (leaving them alone if no entry is present). If the mapper
/// contains entries for function arguments, these arguments are not
/// included in the new function. Replaces references to cloned sub-values
/// with the corresponding value that is copied, and adds those mappings to
/// the mapper.
FuncOp clone(BlockAndValueMapping &mapper);
FuncOp clone();
/// Clone the internal blocks and attributes from this function into dest.
/// Any cloned blocks are appended to the back of dest. This function
/// asserts that the attributes of the current function and dest are
/// compatible.
void cloneInto(FuncOp dest, BlockAndValueMapping &mapper);
//===------------------------------------------------------------------===//
// CallableOpInterface
//===------------------------------------------------------------------===//
/// Returns the region on the current operation that is callable. This may
/// return null in the case of an external callable object, e.g. an external
/// function.
::mlir::Region *getCallableRegion() { return isExternal() ? nullptr : &getBody(); }
/// Returns the results types that the callable region produces when
/// executed.
ArrayRef<Type> getCallableResults() { return getType().getResults(); }
//===------------------------------------------------------------------===//
// FunctionOpInterface Methods
//===------------------------------------------------------------------===//
/// Returns the argument types of this function.
ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); }
/// Returns the result types of this function.
ArrayRef<Type> getResultTypes() { return getType().getResults(); }
//===------------------------------------------------------------------===//
// SymbolOpInterface Methods
//===------------------------------------------------------------------===//
bool isDeclaration() { return isExternal(); }
}];
let hasCustomAssemblyFormat = 1;
}
//===----------------------------------------------------------------------===//
// ReturnOp // ReturnOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ReturnOp : Func_Op<"return", [NoSideEffect, HasParent<"FuncOp">, def ReturnOp : Func_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
MemRefsNormalizable, ReturnLike, Terminator]> { MemRefsNormalizable, ReturnLike, Terminator]> {
let summary = "Function return operation"; let summary = "Function return operation";
let description = [{ let description = [{
The `func.return` operation represents a return operation within a function. The `func.return` operation represents a return operation within a function.
Show All 25 Lines

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

//===-- Passes.td - Func pass definition file --------------*- tablegen -*-===// //===-- Passes.td - Func pass definition file --------------*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_FUNC_TRANSFORMS_PASSES_TD #ifndef MLIR_DIALECT_FUNC_TRANSFORMS_PASSES_TD
#define MLIR_DIALECT_FUNC_TRANSFORMS_PASSES_TD #define MLIR_DIALECT_FUNC_TRANSFORMS_PASSES_TD
include "mlir/Pass/PassBase.td" include "mlir/Pass/PassBase.td"
def FuncBufferize : Pass<"func-bufferize", "ModuleOp"> { def FuncBufferize : Pass<"func-bufferize", "ModuleOp"> {
let summary = "Bufferize func/call/return ops"; let summary = "Bufferize func/call/return ops";
let description = [{ let description = [{
A bufferize pass that bufferizes builtin.func and func.call ops. A bufferize pass that bufferizes func.func and func.call ops.
Because this pass updates builtin.func ops, it must be a module pass. It is Because this pass updates func.func ops, it must be a module pass. It is
useful to keep this pass separate from other bufferizations so that the useful to keep this pass separate from other bufferizations so that the
other ones can be run at function-level in parallel. other ones can be run at function-level in parallel.
This pass must be done atomically because it changes func op signatures, This pass must be done atomically because it changes func op signatures,
which requires atomically updating calls as well throughout the entire which requires atomically updating calls as well throughout the entire
module. module.
This pass also changes the type of block arguments, which requires that all This pass also changes the type of block arguments, which requires that all
Show All 16 Lines

mlir/include/mlir/Dialect/GPU/Passes.h

Show All 17 Lines
namespace llvm { namespace llvm {
class TargetMachine; class TargetMachine;
class LLVMContext; class LLVMContext;
class Module; class Module;
} // namespace llvm } // namespace llvm
namespace mlir { namespace mlir {
namespace func {
class FuncOp;
} // namespace func
/// Pass that moves ops which are likely an index computation into gpu.launch /// Pass that moves ops which are likely an index computation into gpu.launch
/// body. /// body.
std::unique_ptr<Pass> createGpuLauchSinkIndexComputationsPass(); std::unique_ptr<Pass> createGpuLauchSinkIndexComputationsPass();
/// Replaces `gpu.launch` with `gpu.launch_func` by moving the region into /// Replaces `gpu.launch` with `gpu.launch_func` by moving the region into
/// a separate kernel function. /// a separate kernel function.
std::unique_ptr<OperationPass<ModuleOp>> std::unique_ptr<OperationPass<ModuleOp>>
createGpuKernelOutliningPass(StringRef dataLayoutStr = StringRef()); createGpuKernelOutliningPass(StringRef dataLayoutStr = StringRef());
/// Rewrites a function region so that GPU ops execute asynchronously. /// Rewrites a function region so that GPU ops execute asynchronously.
std::unique_ptr<OperationPass<FuncOp>> createGpuAsyncRegionPass(); std::unique_ptr<OperationPass<func::FuncOp>> createGpuAsyncRegionPass();
/// Collect a set of patterns to rewrite all-reduce ops within the GPU dialect. /// Collect a set of patterns to rewrite all-reduce ops within the GPU dialect.
void populateGpuAllReducePatterns(RewritePatternSet &patterns); void populateGpuAllReducePatterns(RewritePatternSet &patterns);
/// Collect all patterns to rewrite ops within the GPU dialect. /// Collect all patterns to rewrite ops within the GPU dialect.
inline void populateGpuRewritePatterns(RewritePatternSet &patterns) { inline void populateGpuRewritePatterns(RewritePatternSet &patterns) {
populateGpuAllReducePatterns(patterns); populateGpuAllReducePatterns(patterns);
} }
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h

//===- DependenceAnalysis.h - Dependence analysis on SSA views --*- C++ -*-===// //===- DependenceAnalysis.h - Dependence analysis on SSA views --*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_LINALG_ANALYSIS_DEPENDENCEANALYSIS_H_ #ifndef MLIR_DIALECT_LINALG_ANALYSIS_DEPENDENCEANALYSIS_H_
#define MLIR_DIALECT_LINALG_ANALYSIS_DEPENDENCEANALYSIS_H_ #define MLIR_DIALECT_LINALG_ANALYSIS_DEPENDENCEANALYSIS_H_
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/OpDefinition.h" #include "mlir/IR/OpDefinition.h"
namespace mlir { namespace mlir {
namespace func {
class FuncOp; class FuncOp;
} // namespace func
namespace linalg { namespace linalg {
class LinalgOp; class LinalgOp;
/// A very primitive alias analysis which just records for each view, either: /// A very primitive alias analysis which just records for each view, either:
/// 1. The base buffer, or /// 1. The base buffer, or
/// 2. The block argument view /// 2. The block argument view
▲ Show 20 Lines • Show All 124 Lines • ▼ Show 20 Linespublic:
using LinalgDependences = SmallVector<LinalgDependenceGraphElem, 8>; using LinalgDependences = SmallVector<LinalgDependenceGraphElem, 8>;
using DependenceGraph = DenseMap<Operation *, LinalgDependences>; using DependenceGraph = DenseMap<Operation *, LinalgDependences>;
using dependence_iterator = LinalgDependences::const_iterator; using dependence_iterator = LinalgDependences::const_iterator;
using dependence_range = iterator_range<dependence_iterator>; using dependence_range = iterator_range<dependence_iterator>;
static StringRef getDependenceTypeStr(DependenceType depType); static StringRef getDependenceTypeStr(DependenceType depType);
// Builds a linalg dependence graph for the ops of type LinalgOp under `f`. // Builds a linalg dependence graph for the ops of type LinalgOp under `f`.
static LinalgDependenceGraph buildDependenceGraph(Aliases &aliases, FuncOp f); static LinalgDependenceGraph buildDependenceGraph(Aliases &aliases,
func::FuncOp f);
LinalgDependenceGraph(Aliases &aliases, ArrayRef<LinalgOp> ops); LinalgDependenceGraph(Aliases &aliases, ArrayRef<LinalgOp> ops);
/// Returns the X such that op -> X is a dependence of type dt. /// Returns the X such that op -> X is a dependence of type dt.
dependence_range getDependencesFrom(Operation *src, DependenceType dt) const; dependence_range getDependencesFrom(Operation *src, DependenceType dt) const;
dependence_range getDependencesFrom(LinalgOp src, DependenceType dt) const; dependence_range getDependencesFrom(LinalgOp src, DependenceType dt) const;
/// Returns the X such that X -> op is a dependence of type dt. /// Returns the X such that X -> op is a dependence of type dt.
dependence_range getDependencesInto(Operation *dst, DependenceType dt) const; dependence_range getDependencesInto(Operation *dst, DependenceType dt) const;
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Linalg/Passes.h

Show All 12 Lines
#ifndef MLIR_DIALECT_LINALG_PASSES_H_ #ifndef MLIR_DIALECT_LINALG_PASSES_H_
#define MLIR_DIALECT_LINALG_PASSES_H_ #define MLIR_DIALECT_LINALG_PASSES_H_
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
namespace func {
class FuncOp;
} // namespace func
// TODO: Remove when all references have been updated.
using FuncOp = func::FuncOp;
namespace bufferization { namespace bufferization {
struct OneShotBufferizationOptions; struct OneShotBufferizationOptions;
} // namespace bufferization } // namespace bufferization
std::unique_ptr<Pass> createConvertElementwiseToLinalgPass(); std::unique_ptr<Pass> createConvertElementwiseToLinalgPass();
std::unique_ptr<Pass> createLinalgFoldUnitExtentDimsPass(); std::unique_ptr<Pass> createLinalgFoldUnitExtentDimsPass();
std::unique_ptr<Pass> createLinalgElementwiseOpFusionPass(); std::unique_ptr<Pass> createLinalgElementwiseOpFusionPass();
std::unique_ptr<Pass> createFoldReshapeOpsByLinearizationPass(); std::unique_ptr<Pass> createFoldReshapeOpsByLinearizationPass();
std::unique_ptr<Pass> createLinalgNamedOpConversionPass(); std::unique_ptr<Pass> createLinalgNamedOpConversionPass();
std::unique_ptr<OperationPass<FuncOp>> std::unique_ptr<OperationPass<func::FuncOp>>
createLinalgTilingPass(ArrayRef<int64_t> tileSizes = {}, createLinalgTilingPass(ArrayRef<int64_t> tileSizes = {},
linalg::LinalgTilingLoopType loopType = linalg::LinalgTilingLoopType loopType =
linalg::LinalgTilingLoopType::Loops); linalg::LinalgTilingLoopType::Loops);
std::unique_ptr<OperationPass<FuncOp>> std::unique_ptr<OperationPass<func::FuncOp>>
createLinalgPromotionPass(bool dynamicBuffers, bool useAlloca); createLinalgPromotionPass(bool dynamicBuffers, bool useAlloca);
std::unique_ptr<OperationPass<FuncOp>> createLinalgPromotionPass(); std::unique_ptr<OperationPass<func::FuncOp>> createLinalgPromotionPass();
std::unique_ptr<OperationPass<FuncOp>> createLinalgInlineScalarOperandsPass(); std::unique_ptr<OperationPass<func::FuncOp>>
createLinalgInlineScalarOperandsPass();
/// Create a pass to convert Linalg operations to scf.for loops and /// Create a pass to convert Linalg operations to scf.for loops and
/// memref.load/memref.store accesses. /// memref.load/memref.store accesses.
std::unique_ptr<OperationPass<FuncOp>> createConvertLinalgToLoopsPass(); std::unique_ptr<OperationPass<func::FuncOp>> createConvertLinalgToLoopsPass();
/// Create a pass to convert Linalg operations to scf.parallel loops and /// Create a pass to convert Linalg operations to scf.parallel loops and
/// memref.load/memref.store accesses. /// memref.load/memref.store accesses.
std::unique_ptr<OperationPass<FuncOp>> createConvertLinalgToParallelLoopsPass(); std::unique_ptr<OperationPass<func::FuncOp>>
createConvertLinalgToParallelLoopsPass();
/// Create a pass to convert Linalg operations to affine.for loops and /// Create a pass to convert Linalg operations to affine.for loops and
/// affine_load/affine_store accesses. /// affine_load/affine_store accesses.
/// Placeholder for now, this is NYI. /// Placeholder for now, this is NYI.
std::unique_ptr<OperationPass<FuncOp>> createConvertLinalgToAffineLoopsPass(); std::unique_ptr<OperationPass<func::FuncOp>>
createConvertLinalgToAffineLoopsPass();
/// This pass implements a cross-dialect bufferization approach and performs an /// This pass implements a cross-dialect bufferization approach and performs an
/// analysis to determine which op operands and results may be bufferized in the /// analysis to determine which op operands and results may be bufferized in the
/// same buffers. The analysis is performed on topologically sorted CallOp and /// same buffers. The analysis is performed on topologically sorted CallOp and
/// FuncOp within a module. It provides analyses and bufferization across /// FuncOp within a module. It provides analyses and bufferization across
/// function boundaries. Within a function boundary, the analysis is performed /// function boundaries. Within a function boundary, the analysis is performed
/// on SSA use-def chains starting from function operands that are annotated /// on SSA use-def chains starting from function operands that are annotated
/// with the 'inplaceable' attribute. /// with the 'inplaceable' attribute.
std::unique_ptr<Pass> createLinalgComprehensiveModuleBufferizePass(); std::unique_ptr<Pass> createLinalgComprehensiveModuleBufferizePass();
std::unique_ptr<Pass> createLinalgComprehensiveModuleBufferizePass( std::unique_ptr<Pass> createLinalgComprehensiveModuleBufferizePass(
const bufferization::OneShotBufferizationOptions &options); const bufferization::OneShotBufferizationOptions &options);
/// Create a pass to convert Linalg operations which work on tensors to use /// Create a pass to convert Linalg operations which work on tensors to use
/// buffers instead. /// buffers instead.
std::unique_ptr<OperationPass<FuncOp>> createLinalgBufferizePass(); std::unique_ptr<OperationPass<func::FuncOp>> createLinalgBufferizePass();
/// Create a pass to convert named Linalg operations to Linalg generic /// Create a pass to convert named Linalg operations to Linalg generic
/// operations. /// operations.
std::unique_ptr<OperationPass<FuncOp>> createLinalgGeneralizationPass(); std::unique_ptr<OperationPass<func::FuncOp>> createLinalgGeneralizationPass();
/// Create a pass to convert Linalg operations to equivalent operations that /// Create a pass to convert Linalg operations to equivalent operations that
/// work on primitive types, if possible. /// work on primitive types, if possible.
std::unique_ptr<Pass> createLinalgDetensorizePass(); std::unique_ptr<Pass> createLinalgDetensorizePass();
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Linalg strategy passes. /// Linalg strategy passes.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Create a LinalgStrategyTileAndFusePass. /// Create a LinalgStrategyTileAndFusePass.
std::unique_ptr<OperationPass<FuncOp>> createLinalgStrategyTileAndFusePass( std::unique_ptr<OperationPass<func::FuncOp>>
createLinalgStrategyTileAndFusePass(
StringRef opName = "", const linalg::LinalgTilingAndFusionOptions &opt = {}, StringRef opName = "", const linalg::LinalgTilingAndFusionOptions &opt = {},
const linalg::LinalgTransformationFilter &filter = const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter()); linalg::LinalgTransformationFilter());
/// Create a LinalgStrategyTilePass. /// Create a LinalgStrategyTilePass.
std::unique_ptr<OperationPass<FuncOp>> createLinalgStrategyTilePass( std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyTilePass(
StringRef opName = "", StringRef opName = "",
const linalg::LinalgTilingOptions &opt = linalg::LinalgTilingOptions(), const linalg::LinalgTilingOptions &opt = linalg::LinalgTilingOptions(),
const linalg::LinalgTransformationFilter &filter = const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter()); linalg::LinalgTransformationFilter());
/// Create a LinalgStrategyPadPass. /// Create a LinalgStrategyPadPass.
std::unique_ptr<OperationPass<FuncOp>> createLinalgStrategyPadPass( std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyPadPass(
StringRef opName = "", StringRef opName = "",
const linalg::LinalgPaddingOptions &opt = linalg::LinalgPaddingOptions(), const linalg::LinalgPaddingOptions &opt = linalg::LinalgPaddingOptions(),
const linalg::LinalgTransformationFilter &filter = const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter()); linalg::LinalgTransformationFilter());
/// Create a LinalgStrategyPromotePass. /// Create a LinalgStrategyPromotePass.
std::unique_ptr<OperationPass<FuncOp>> createLinalgStrategyPromotePass( std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyPromotePass(
StringRef opName = "", StringRef opName = "",
const linalg::LinalgPromotionOptions &opt = const linalg::LinalgPromotionOptions &opt =
linalg::LinalgPromotionOptions(), linalg::LinalgPromotionOptions(),
const linalg::LinalgTransformationFilter &filter = const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter()); linalg::LinalgTransformationFilter());
/// Create a LinalgStrategyGeneralizePass. /// Create a LinalgStrategyGeneralizePass.
std::unique_ptr<OperationPass<FuncOp>> createLinalgStrategyGeneralizePass( std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyGeneralizePass(
StringRef opName = "", const linalg::LinalgTransformationFilter &filter = StringRef opName = "", const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter()); linalg::LinalgTransformationFilter());
/// Create a LinalgStrategyDecomposePass. /// Create a LinalgStrategyDecomposePass.
// TODO: if/when we need finer control add an `opName` parameter. // TODO: if/when we need finer control add an `opName` parameter.
std::unique_ptr<OperationPass<FuncOp>> createLinalgStrategyDecomposePass( std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyDecomposePass(
const linalg::LinalgTransformationFilter &filter = const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter()); linalg::LinalgTransformationFilter());
/// Create a LinalgStrategyInterchangePass. /// Create a LinalgStrategyInterchangePass.
std::unique_ptr<OperationPass<FuncOp>> createLinalgStrategyInterchangePass( std::unique_ptr<OperationPass<func::FuncOp>>
createLinalgStrategyInterchangePass(
ArrayRef<int64_t> iteratorInterchange = {}, ArrayRef<int64_t> iteratorInterchange = {},
const linalg::LinalgTransformationFilter &filter = const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter()); linalg::LinalgTransformationFilter());
/// Create a LinalgStrategyVectorizePass. /// Create a LinalgStrategyVectorizePass.
std::unique_ptr<OperationPass<FuncOp>> createLinalgStrategyVectorizePass( std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyVectorizePass(
StringRef opName = "", StringRef opName = "",
linalg::LinalgVectorizationOptions opt = linalg::LinalgVectorizationOptions opt =
linalg::LinalgVectorizationOptions(), linalg::LinalgVectorizationOptions(),
const linalg::LinalgTransformationFilter &filter = const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter(), linalg::LinalgTransformationFilter(),
bool padVectorize = false); bool padVectorize = false);
/// Create a LinalgStrategyEnablePass. /// Create a LinalgStrategyEnablePass.
std::unique_ptr<OperationPass<FuncOp>> createLinalgStrategyEnablePass( std::unique_ptr<OperationPass<func::FuncOp>> createLinalgStrategyEnablePass(
linalg::LinalgEnablingOptions opt = linalg::LinalgEnablingOptions(), linalg::LinalgEnablingOptions opt = linalg::LinalgEnablingOptions(),
const linalg::LinalgTransformationFilter &filter = const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter()); linalg::LinalgTransformationFilter());
/// Create a LinalgStrategyLowerVectorsPass. /// Create a LinalgStrategyLowerVectorsPass.
std::unique_ptr<OperationPass<FuncOp>> createLinalgStrategyLowerVectorsPass( std::unique_ptr<OperationPass<func::FuncOp>>
createLinalgStrategyLowerVectorsPass(
linalg::LinalgVectorLoweringOptions opt = linalg::LinalgVectorLoweringOptions opt =
linalg::LinalgVectorLoweringOptions(), linalg::LinalgVectorLoweringOptions(),
const linalg::LinalgTransformationFilter &filter = const linalg::LinalgTransformationFilter &filter =
linalg::LinalgTransformationFilter()); linalg::LinalgTransformationFilter());
/// Create a LinalgStrategyRemoveMarkersPass. /// Create a LinalgStrategyRemoveMarkersPass.
std::unique_ptr<OperationPass<FuncOp>> createLinalgStrategyRemoveMarkersPass(); std::unique_ptr<OperationPass<func::FuncOp>>
createLinalgStrategyRemoveMarkersPass();
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Registration // Registration
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Generate the code for registering passes. /// Generate the code for registering passes.
#define GEN_PASS_REGISTRATION #define GEN_PASS_REGISTRATION
#include "mlir/Dialect/Linalg/Passes.h.inc" #include "mlir/Dialect/Linalg/Passes.h.inc"
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_LINALG_PASSES_H_ #endif // MLIR_DIALECT_LINALG_PASSES_H_

mlir/include/mlir/Dialect/Linalg/Transforms/Hoisting.h

//===- Hoisting.h - Linalg hoisting transformations -------------*- C++ -*-===// //===- Hoisting.h - Linalg hoisting transformations -------------*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_LINALG_TRANSFORMS_HOISTING_H_ #ifndef MLIR_DIALECT_LINALG_TRANSFORMS_HOISTING_H_
#define MLIR_DIALECT_LINALG_TRANSFORMS_HOISTING_H_ #define MLIR_DIALECT_LINALG_TRANSFORMS_HOISTING_H_
namespace mlir { namespace mlir {
namespace func {
class FuncOp; class FuncOp;
} // namespace func
namespace linalg { namespace linalg {
/// Hoist vector.transfer_read/vector.transfer_write on buffers pairs out of /// Hoist vector.transfer_read/vector.transfer_write on buffers pairs out of
/// immediately enclosing scf::ForOp iteratively, if the following conditions /// immediately enclosing scf::ForOp iteratively, if the following conditions
/// are true: /// are true:
/// 1. The two ops access the same memref with the same indices. /// 1. The two ops access the same memref with the same indices.
/// 2. All operands are invariant under the enclosing scf::ForOp. /// 2. All operands are invariant under the enclosing scf::ForOp.
/// 3. No uses of the memref either dominate the transfer_read or are /// 3. No uses of the memref either dominate the transfer_read or are
/// dominated by the transfer_write (i.e. no aliasing between the write and /// dominated by the transfer_write (i.e. no aliasing between the write and
/// the read across the loop) /// the read across the loop)
/// To improve hoisting opportunities, call the `moveLoopInvariantCode` helper /// To improve hoisting opportunities, call the `moveLoopInvariantCode` helper
/// function on the candidate loop above which to hoist. Hoisting the transfers /// function on the candidate loop above which to hoist. Hoisting the transfers
/// results in scf::ForOp yielding the value that originally transited through /// results in scf::ForOp yielding the value that originally transited through
/// memory. /// memory.
// TODO: generalize on a per-need basis. // TODO: generalize on a per-need basis.
void hoistRedundantVectorTransfers(FuncOp func); void hoistRedundantVectorTransfers(func::FuncOp func);
/// Same behavior as `hoistRedundantVectorTransfers` but works on tensors /// Same behavior as `hoistRedundantVectorTransfers` but works on tensors
/// instead of buffers. /// instead of buffers.
void hoistRedundantVectorTransfersOnTensor(FuncOp func); void hoistRedundantVectorTransfersOnTensor(func::FuncOp func);
} // namespace linalg } // namespace linalg
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_LINALG_TRANSFORMS_HOISTING_H_ #endif // MLIR_DIALECT_LINALG_TRANSFORMS_HOISTING_H_

mlir/include/mlir/Dialect/Quant/Passes.h

Show All 13 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_QUANT_PASSES_H #ifndef MLIR_DIALECT_QUANT_PASSES_H
#define MLIR_DIALECT_QUANT_PASSES_H #define MLIR_DIALECT_QUANT_PASSES_H
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
namespace func {
class FuncOp;
} // namespace func
namespace quant { namespace quant {
/// Creates a pass that converts quantization simulation operations (i.e. /// Creates a pass that converts quantization simulation operations (i.e.
/// FakeQuant and those like it) to casts into/out of supported QuantizedTypes. /// FakeQuant and those like it) to casts into/out of supported QuantizedTypes.
std::unique_ptr<OperationPass<FuncOp>> createConvertSimulatedQuantPass(); std::unique_ptr<OperationPass<func::FuncOp>> createConvertSimulatedQuantPass();
/// Creates a pass that converts constants followed by a qbarrier to a /// Creates a pass that converts constants followed by a qbarrier to a
/// constant whose value is quantized. This is typically one of the last /// constant whose value is quantized. This is typically one of the last
/// passes done when lowering to express actual quantized arithmetic in a /// passes done when lowering to express actual quantized arithmetic in a
/// low level representation. Because it modifies the constant, it is /// low level representation. Because it modifies the constant, it is
/// destructive and cannot be undone. /// destructive and cannot be undone.
std::unique_ptr<OperationPass<FuncOp>> createConvertConstPass(); std::unique_ptr<OperationPass<func::FuncOp>> createConvertConstPass();
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Registration // Registration
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Generate the code for registering passes. /// Generate the code for registering passes.
#define GEN_PASS_REGISTRATION #define GEN_PASS_REGISTRATION
#include "mlir/Dialect/Quant/Passes.h.inc" #include "mlir/Dialect/Quant/Passes.h.inc"
} // namespace quant } // namespace quant
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_QUANT_PASSES_H #endif // MLIR_DIALECT_QUANT_PASSES_H

mlir/include/mlir/Dialect/SCF/Utils/Utils.h

Show All 13 Lines
#define MLIR_DIALECT_SCF_UTILS_UTILS_H_ #define MLIR_DIALECT_SCF_UTILS_UTILS_H_
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Support/LLVM.h" #include "mlir/Support/LLVM.h"
#include "mlir/Support/LogicalResult.h" #include "mlir/Support/LogicalResult.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
namespace mlir { namespace mlir {
class FuncOp;
class Location; class Location;
class Operation; class Operation;
class OpBuilder; class OpBuilder;
class Region; class Region;
class RewriterBase; class RewriterBase;
class ValueRange; class ValueRange;
class Value; class Value;
namespace func {
class FuncOp;
} // namespace func
namespace scf { namespace scf {
class IfOp; class IfOp;
class ForOp; class ForOp;
class ParallelOp; class ParallelOp;
} // namespace scf } // namespace scf
/// Create a clone of `loop` with `newIterOperands` added as new initialization /// Create a clone of `loop` with `newIterOperands` added as new initialization
/// values and `newYieldedValues` added as new yielded values. The returned /// values and `newYieldedValues` added as new yielded values. The returned
Show All 24 Lines
/// single block. This constraint makes it easy to determine the result. /// single block. This constraint makes it easy to determine the result.
/// This method also clones the `arith::ConstantIndexOp` at the start of /// This method also clones the `arith::ConstantIndexOp` at the start of
/// `outlinedFuncBody` to alloc simple canonicalizations. /// `outlinedFuncBody` to alloc simple canonicalizations.
/// Creates a new FuncOp and thus cannot be used in a FuncOp pass. /// Creates a new FuncOp and thus cannot be used in a FuncOp pass.
/// The client is responsible for providing a unique `funcName` that will not /// The client is responsible for providing a unique `funcName` that will not
/// collide with another FuncOp name. /// collide with another FuncOp name.
// TODO: support more than single-block regions. // TODO: support more than single-block regions.
// TODO: more flexible constant handling. // TODO: more flexible constant handling.
FailureOr<FuncOp> outlineSingleBlockRegion(RewriterBase &rewriter, Location loc, FailureOr<func::FuncOp> outlineSingleBlockRegion(RewriterBase &rewriter,
Region &region, StringRef funcName); Location loc, Region &region,
StringRef funcName);
/// Outline the then and/or else regions of `ifOp` as follows: /// Outline the then and/or else regions of `ifOp` as follows:
/// - if `thenFn` is not null, `thenFnName` must be specified and the `then` /// - if `thenFn` is not null, `thenFnName` must be specified and the `then`
/// region is inlined into a new FuncOp that is captured by the pointer. /// region is inlined into a new FuncOp that is captured by the pointer.
/// - if `elseFn` is not null, `elseFnName` must be specified and the `else` /// - if `elseFn` is not null, `elseFnName` must be specified and the `else`
/// region is inlined into a new FuncOp that is captured by the pointer. /// region is inlined into a new FuncOp that is captured by the pointer.
/// Creates new FuncOps and thus cannot be used in a FuncOp pass. /// Creates new FuncOps and thus cannot be used in a FuncOp pass.
/// The client is responsible for providing a unique `thenFnName`/`elseFnName` /// The client is responsible for providing a unique `thenFnName`/`elseFnName`
/// that will not collide with another FuncOp name. /// that will not collide with another FuncOp name.
LogicalResult outlineIfOp(RewriterBase &b, scf::IfOp ifOp, FuncOp *thenFn, LogicalResult outlineIfOp(RewriterBase &b, scf::IfOp ifOp, func::FuncOp *thenFn,
StringRef thenFnName, FuncOp *elseFn, StringRef thenFnName, func::FuncOp *elseFn,
StringRef elseFnName); StringRef elseFnName);
/// Get a list of innermost parallel loops contained in `rootOp`. Innermost /// Get a list of innermost parallel loops contained in `rootOp`. Innermost
/// parallel loops are those that do not contain further parallel loops /// parallel loops are those that do not contain further parallel loops
/// themselves. /// themselves.
bool getInnermostParallelLoops(Operation *rootOp, bool getInnermostParallelLoops(Operation *rootOp,
SmallVectorImpl<scf::ParallelOp> &result); SmallVectorImpl<scf::ParallelOp> &result);
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Shape/IR/Shape.h

Show All 9 Lines
// relations of MLIR operations using ShapedType. // relations of MLIR operations using ShapedType.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_SHAPE_IR_SHAPE_H #ifndef MLIR_DIALECT_SHAPE_IR_SHAPE_H
#define MLIR_DIALECT_SHAPE_IR_SHAPE_H #define MLIR_DIALECT_SHAPE_IR_SHAPE_H
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/IR/OpDefinition.h" #include "mlir/IR/OpDefinition.h"
#include "mlir/IR/OpImplementation.h" #include "mlir/IR/OpImplementation.h"
#include "mlir/IR/SymbolTable.h" #include "mlir/IR/SymbolTable.h"
#include "mlir/Interfaces/ControlFlowInterfaces.h" #include "mlir/Interfaces/ControlFlowInterfaces.h"
#include "mlir/Interfaces/InferTypeOpInterface.h" #include "mlir/Interfaces/InferTypeOpInterface.h"
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

mlir/include/mlir/IR/BuiltinOps.h

//===- BuiltinOps.h - MLIR Builtin Operations -------------------*- C++ -*-===// //===- BuiltinOps.h - MLIR Builtin 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 contains the Builtin dialect's operations. // This file contains the Builtin dialect's operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_IR_BUILTINOPS_H_ #ifndef MLIR_IR_BUILTINOPS_H_
#define MLIR_IR_BUILTINOPS_H_ #define MLIR_IR_BUILTINOPS_H_
#include "mlir/IR/FunctionInterfaces.h"
#include "mlir/IR/OpImplementation.h" #include "mlir/IR/OpImplementation.h"
#include "mlir/IR/OwningOpRef.h" #include "mlir/IR/OwningOpRef.h"
#include "mlir/IR/RegionKindInterface.h" #include "mlir/IR/RegionKindInterface.h"
#include "mlir/IR/SymbolTable.h" #include "mlir/IR/SymbolTable.h"
#include "mlir/Interfaces/CallInterfaces.h"
#include "mlir/Interfaces/CastInterfaces.h" #include "mlir/Interfaces/CastInterfaces.h"
#include "mlir/Interfaces/DataLayoutInterfaces.h" #include "mlir/Interfaces/DataLayoutInterfaces.h"
#include "mlir/Interfaces/SideEffectInterfaces.h" #include "mlir/Interfaces/SideEffectInterfaces.h"
#include "llvm/Support/PointerLikeTypeTraits.h" #include "llvm/Support/PointerLikeTypeTraits.h"
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Dialect Operations // Dialect Operations
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "mlir/IR/BuiltinOps.h.inc" #include "mlir/IR/BuiltinOps.h.inc"
namespace llvm { namespace llvm {
/// Allow stealing the low bits of FuncOp.
template <>
struct PointerLikeTypeTraits<mlir::FuncOp> {
static inline void *getAsVoidPointer(mlir::FuncOp val) {
return const_cast<void *>(val.getAsOpaquePointer());
}
static inline mlir::FuncOp getFromVoidPointer(void *p) {
return mlir::FuncOp::getFromOpaquePointer(p);
}
static constexpr int numLowBitsAvailable = 3;
};
/// Allow stealing the low bits of ModuleOp. /// Allow stealing the low bits of ModuleOp.
template <> template <>
struct PointerLikeTypeTraits<mlir::ModuleOp> { struct PointerLikeTypeTraits<mlir::ModuleOp> {
public: public:
static inline void *getAsVoidPointer(mlir::ModuleOp val) { static inline void *getAsVoidPointer(mlir::ModuleOp val) {
return const_cast<void *>(val.getAsOpaquePointer()); return const_cast<void *>(val.getAsOpaquePointer());
} }
static inline mlir::ModuleOp getFromVoidPointer(void *p) { static inline mlir::ModuleOp getFromVoidPointer(void *p) {
return mlir::ModuleOp::getFromOpaquePointer(p); return mlir::ModuleOp::getFromOpaquePointer(p);
} }
static constexpr int numLowBitsAvailable = 3; static constexpr int numLowBitsAvailable = 3;
}; };
} // namespace llvm } // namespace llvm
#endif // MLIR_IR_BUILTINOPS_H_ #endif // MLIR_IR_BUILTINOPS_H_

mlir/include/mlir/IR/BuiltinOps.td

Show All 9 Lines
// necessary for the validity of and defining the IR. // necessary for the validity of and defining the IR.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef BUILTIN_OPS #ifndef BUILTIN_OPS
#define BUILTIN_OPS #define BUILTIN_OPS
include "mlir/IR/BuiltinDialect.td" include "mlir/IR/BuiltinDialect.td"
include "mlir/IR/FunctionInterfaces.td"
include "mlir/IR/OpAsmInterface.td" include "mlir/IR/OpAsmInterface.td"
include "mlir/IR/RegionKindInterface.td" include "mlir/IR/RegionKindInterface.td"
include "mlir/IR/SymbolInterfaces.td" include "mlir/IR/SymbolInterfaces.td"
include "mlir/Interfaces/CallInterfaces.td"
include "mlir/Interfaces/CastInterfaces.td" include "mlir/Interfaces/CastInterfaces.td"
include "mlir/Interfaces/DataLayoutInterfaces.td" include "mlir/Interfaces/DataLayoutInterfaces.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
// Base class for Builtin dialect ops. // Base class for Builtin dialect ops.
class Builtin_Op<string mnemonic, list<Trait> traits = []> : class Builtin_Op<string mnemonic, list<Trait> traits = []> :
Op<Builtin_Dialect, mnemonic, traits>; Op<Builtin_Dialect, mnemonic, traits>;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// FuncOp
//===----------------------------------------------------------------------===//
def FuncOp : Builtin_Op<"func", [
AffineScope, AutomaticAllocationScope, CallableOpInterface,
FunctionOpInterface, IsolatedFromAbove, Symbol
]> {
let summary = "An operation with a name containing a single `SSACFG` region";
let description = [{
Operations within the function cannot implicitly capture values defined
outside of the function, i.e. Functions are `IsolatedFromAbove`. All
external references must use function arguments or attributes that establish
a symbolic connection (e.g. symbols referenced by name via a string
attribute like SymbolRefAttr). An external function declaration (used when
referring to a function declared in some other module) has no body. While
the MLIR textual form provides a nice inline syntax for function arguments,
they are internally represented as “block arguments” to the first block in
the region.
Only dialect attribute names may be specified in the attribute dictionaries
for function arguments, results, or the function itself.
Example:
```mlir
// External function definitions.
func @abort()
func @scribble(i32, i64, memref<? x 128 x f32, #layout_map0>) -> f64
// A function that returns its argument twice:
func @count(%x: i64) -> (i64, i64)
attributes {fruit: "banana"} {
return %x, %x: i64, i64
}
// A function with an argument attribute
func @example_fn_arg(%x: i32 {swift.self = unit})
// A function with a result attribute
func @example_fn_result() -> (f64 {dialectName.attrName = 0 : i64})
// A function with an attribute
func @example_fn_attr() attributes {dialectName.attrName = false}
```
}];
let arguments = (ins SymbolNameAttr:$sym_name,
TypeAttrOf<FunctionType>:$type,
OptionalAttr<StrAttr>:$sym_visibility);
let regions = (region AnyRegion:$body);
let builders = [OpBuilder<(ins
"StringRef":$name, "FunctionType":$type,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs,
CArg<"ArrayRef<DictionaryAttr>", "{}">:$argAttrs)
>];
let extraClassDeclaration = [{
static FuncOp create(Location location, StringRef name, FunctionType type,
ArrayRef<NamedAttribute> attrs = {});
static FuncOp create(Location location, StringRef name, FunctionType type,
Operation::dialect_attr_range attrs);
static FuncOp create(Location location, StringRef name, FunctionType type,
ArrayRef<NamedAttribute> attrs,
ArrayRef<DictionaryAttr> argAttrs);
/// Create a deep copy of this function and all of its blocks, remapping any
/// operands that use values outside of the function using the map that is
/// provided (leaving them alone if no entry is present). If the mapper
/// contains entries for function arguments, these arguments are not
/// included in the new function. Replaces references to cloned sub-values
/// with the corresponding value that is copied, and adds those mappings to
/// the mapper.
FuncOp clone(BlockAndValueMapping &mapper);
FuncOp clone();
/// Clone the internal blocks and attributes from this function into dest.
/// Any cloned blocks are appended to the back of dest. This function
/// asserts that the attributes of the current function and dest are
/// compatible.
void cloneInto(FuncOp dest, BlockAndValueMapping &mapper);
//===------------------------------------------------------------------===//
// CallableOpInterface
//===------------------------------------------------------------------===//
/// Returns the region on the current operation that is callable. This may
/// return null in the case of an external callable object, e.g. an external
/// function.
::mlir::Region *getCallableRegion() { return isExternal() ? nullptr : &getBody(); }
/// Returns the results types that the callable region produces when
/// executed.
ArrayRef<Type> getCallableResults() { return getType().getResults(); }
//===------------------------------------------------------------------===//
// FunctionOpInterface Methods
//===------------------------------------------------------------------===//
/// Returns the argument types of this function.
ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); }
/// Returns the result types of this function.
ArrayRef<Type> getResultTypes() { return getType().getResults(); }
//===------------------------------------------------------------------===//
// SymbolOpInterface Methods
//===------------------------------------------------------------------===//
bool isDeclaration() { return isExternal(); }
}];
let hasCustomAssemblyFormat = 1;
}
//===----------------------------------------------------------------------===//
// ModuleOp // ModuleOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ModuleOp : Builtin_Op<"module", [ def ModuleOp : Builtin_Op<"module", [
AffineScope, IsolatedFromAbove, NoRegionArguments, SymbolTable, Symbol, AffineScope, IsolatedFromAbove, NoRegionArguments, SymbolTable, Symbol,
OpAsmOpInterface OpAsmOpInterface
] # GraphRegionNoTerminator.traits> { ] # GraphRegionNoTerminator.traits> {
let summary = "A top level container operation"; let summary = "A top level container operation";
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

mlir/include/mlir/IR/FunctionInterfaces.td

Show First 20 Lines • Show All 152 Lines • ▼ Show 20 Lines let extraSharedClassDeclaration = [{
/// Block list iterator types. /// Block list iterator types.
using BlockListType = Region::BlockListType; using BlockListType = Region::BlockListType;
using iterator = BlockListType::iterator; using iterator = BlockListType::iterator;
using reverse_iterator = BlockListType::reverse_iterator; using reverse_iterator = BlockListType::reverse_iterator;
/// Block argument iterator types. /// Block argument iterator types.
using BlockArgListType = Region::BlockArgListType; using BlockArgListType = Region::BlockArgListType;
using args_iterator = BlockArgListType::iterator; using args_iterator = BlockArgListType::iterator;
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
// Body Handling // Body Handling
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
/// Returns true if this function is external, i.e. it has no body. /// Returns true if this function is external, i.e. it has no body.
bool isExternal() { return empty(); } bool isExternal() { return empty(); }
/// Return the region containing the body of this function. /// Return the region containing the body of this function.
▲ Show 20 Lines • Show All 430 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

Show All 16 Lines
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.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/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlow.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
#include "mlir/Dialect/Func/IR/FuncOps.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/LLVMIR/NVVMDialect.h" #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
▲ Show 20 Lines • Show All 326 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp

Show All 16 Lines
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.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/VectorToLLVM/ConvertVectorToLLVM.h" #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
#include "mlir/Conversion/VectorToROCDL/VectorToROCDL.h" #include "mlir/Conversion/VectorToROCDL/VectorToROCDL.h"
#include "mlir/Dialect/Func/IR/FuncOps.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/LLVMIR/ROCDLDialect.h" #include "mlir/Dialect/LLVMIR/ROCDLDialect.h"
#include "mlir/Dialect/Math/IR/Math.h" #include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.cpp

//===- LinalgToSPIRVPass.cpp - Linalg to SPIR-V Passes --------------------===// //===- LinalgToSPIRVPass.cpp - Linalg 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h" #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h"
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRV.h" #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRV.h"
#include "mlir/Dialect/Func/IR/FuncOps.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 {
/// A pass converting MLIR Linalg ops into SPIR-V ops. /// A pass converting MLIR Linalg ops into SPIR-V ops.
class LinalgToSPIRVPass : public ConvertLinalgToSPIRVBase<LinalgToSPIRVPass> { class LinalgToSPIRVPass : public ConvertLinalgToSPIRVBase<LinalgToSPIRVPass> {
Show All 31 Lines

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

//===- MemRefToLLVM.cpp - MemRef to LLVM dialect conversion ---------------===// //===- MemRefToLLVM.cpp - MemRef 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Analysis/DataLayoutAnalysis.h" #include "mlir/Analysis/DataLayoutAnalysis.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/AllocLikeConversion.h" #include "mlir/Conversion/MemRefToLLVM/AllocLikeConversion.h"
#include "mlir/Dialect/Func/IR/FuncOps.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/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "llvm/ADT/SmallBitVector.h" #include "llvm/ADT/SmallBitVector.h"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 1,849 Lines • Show Last 20 Lines

mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp

//===- ShapeToStandard.cpp - conversion from Shape to Standard dialect ----===// //===- ShapeToStandard.cpp - conversion from Shape to Standard 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/ShapeToStandard/ShapeToStandard.h" #include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h"
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Func/IR/FuncOps.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/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
▲ Show 20 Lines • Show All 689 Lines • Show Last 20 Lines

mlir/lib/Dialect/Affine/Analysis/AffineAnalysis.cpp

Show All 11 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h" #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
#include "mlir/Analysis/SliceAnalysis.h" #include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h" #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/Utils.h" #include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h" #include "mlir/Dialect/Affine/IR/AffineValueMap.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/AffineExprVisitor.h" #include "mlir/IR/AffineExprVisitor.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/IntegerSet.h" #include "mlir/IR/IntegerSet.h"
#include "mlir/Interfaces/ViewLikeInterface.h" #include "mlir/Interfaces/ViewLikeInterface.h"
#include "llvm/ADT/TypeSwitch.h" #include "llvm/ADT/TypeSwitch.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
▲ Show 20 Lines • Show All 671 Lines • Show Last 20 Lines

mlir/lib/Dialect/Affine/Transforms/PassDetail.h

//===- PassDetail.h - Affine Pass class details -----------------*- C++ -*-===// //===- PassDetail.h - Affine Pass class details -----------------*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef DIALECT_AFFINE_TRANSFORMS_PASSDETAIL_H_ #ifndef DIALECT_AFFINE_TRANSFORMS_PASSDETAIL_H_
#define DIALECT_AFFINE_TRANSFORMS_PASSDETAIL_H_ #define DIALECT_AFFINE_TRANSFORMS_PASSDETAIL_H_
#include "mlir/Dialect/Affine/Passes.h" #include "mlir/Dialect/Affine/Passes.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
// Forward declaration from Dialect.h // Forward declaration from Dialect.h
template <typename ConcreteDialect> template <typename ConcreteDialect>
void registerDialect(DialectRegistry &registry); void registerDialect(DialectRegistry &registry);
namespace arith { namespace arith {
Show All 21 Lines

mlir/lib/Dialect/Affine/Utils/LoopFusionUtils.cpp

Show All 12 Lines
#include "mlir/Dialect/Affine/LoopFusionUtils.h" #include "mlir/Dialect/Affine/LoopFusionUtils.h"
#include "mlir/Analysis/SliceAnalysis.h" #include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h" #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineStructures.h" #include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h" #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/Utils.h" #include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h" #include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Func/IR/FuncOps.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/Operation.h" #include "mlir/IR/Operation.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
▲ Show 20 Lines • Show All 636 Lines • Show Last 20 Lines

mlir/lib/Dialect/Affine/Utils/LoopUtils.cpp

Show All 12 Lines
#include "mlir/Dialect/Affine/LoopUtils.h" #include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Analysis/SliceAnalysis.h" #include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h" #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h" #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/Utils.h" #include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h" #include "mlir/Dialect/Affine/IR/AffineValueMap.h"
#include "mlir/Dialect/Affine/Utils.h" #include "mlir/Dialect/Affine/Utils.h"
#include "mlir/Dialect/Func/IR/FuncOps.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/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/IntegerSet.h" #include "mlir/IR/IntegerSet.h"
#include "mlir/Support/MathExtras.h" #include "mlir/Support/MathExtras.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "mlir/Transforms/RegionUtils.h" #include "mlir/Transforms/RegionUtils.h"
#include "llvm/ADT/MapVector.h" #include "llvm/ADT/MapVector.h"
▲ Show 20 Lines • Show All 2,577 Lines • ▼ Show 20 LinesgatherLoopsInBlock(Block *block, unsigned currLoopDepth,
for (auto &op : *block) { for (auto &op : *block) {
if (auto forOp = dyn_cast<AffineForOp>(op)) { if (auto forOp = dyn_cast<AffineForOp>(op)) {
depthToLoops[currLoopDepth].push_back(forOp); depthToLoops[currLoopDepth].push_back(forOp);
gatherLoopsInBlock(forOp.getBody(), currLoopDepth + 1, depthToLoops); gatherLoopsInBlock(forOp.getBody(), currLoopDepth + 1, depthToLoops);
} }
} }
} }
/// Gathers all AffineForOps in 'builtin.func' grouped by loop depth. /// Gathers all AffineForOps in 'func.func' grouped by loop depth.
void mlir::gatherLoops(FuncOp func, void mlir::gatherLoops(FuncOp func,
std::vector<SmallVector<AffineForOp, 2>> &depthToLoops) { std::vector<SmallVector<AffineForOp, 2>> &depthToLoops) {
for (auto &block : func) for (auto &block : func)
gatherLoopsInBlock(&block, /*currLoopDepth=*/0, depthToLoops); gatherLoopsInBlock(&block, /*currLoopDepth=*/0, depthToLoops);
// Remove last loop level from output since it's empty. // Remove last loop level from output since it's empty.
if (!depthToLoops.empty()) { if (!depthToLoops.empty()) {
assert(depthToLoops.back().empty() && "Last loop level is not empty?"); assert(depthToLoops.back().empty() && "Last loop level is not empty?");
▲ Show 20 Lines • Show All 220 Lines • Show Last 20 Lines

mlir/lib/Dialect/Affine/Utils/Utils.cpp

Show All 11 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/Utils.h" #include "mlir/Dialect/Affine/Utils.h"
#include "mlir/Dialect/Affine/Analysis/Utils.h" #include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h" #include "mlir/Dialect/Affine/IR/AffineValueMap.h"
#include "mlir/Dialect/Affine/LoopUtils.h" #include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/AffineExprVisitor.h" #include "mlir/IR/AffineExprVisitor.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Dominance.h" #include "mlir/IR/Dominance.h"
#include "mlir/IR/IntegerSet.h" #include "mlir/IR/IntegerSet.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#define DEBUG_TYPE "affine-utils" #define DEBUG_TYPE "affine-utils"
▲ Show 20 Lines • Show All 1,780 Lines • Show Last 20 Lines

mlir/lib/Dialect/Bufferization/IR/BufferizableOpInterface.cpp

//===- BufferizableOpInterface.cpp - Bufferizable Ops ---=----------------===// //===- BufferizableOpInterface.cpp - Bufferizable Ops ---=----------------===//
// //
// 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/Bufferization/IR/BufferizableOpInterface.h" #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/AsmState.h" #include "mlir/IR/AsmState.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/Operation.h" #include "mlir/IR/Operation.h"
#include "mlir/IR/TypeUtilities.h" #include "mlir/IR/TypeUtilities.h"
#include "mlir/IR/Value.h" #include "mlir/IR/Value.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
▲ Show 20 Lines • Show All 643 Lines • Show Last 20 Lines

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

add_mlir_dialect_library(MLIRBufferization add_mlir_dialect_library(MLIRBufferization
AllocationOpInterface.cpp AllocationOpInterface.cpp
BufferizableOpInterface.cpp BufferizableOpInterface.cpp
BufferizationOps.cpp BufferizationOps.cpp
BufferizationDialect.cpp BufferizationDialect.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Bufferization ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Bufferization
DEPENDS DEPENDS
MLIRAllocationOpInterfaceIncGen MLIRAllocationOpInterfaceIncGen
MLIRBufferizationOpsIncGen MLIRBufferizationOpsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRDialect MLIRDialect
MLIRFunc
MLIRIR MLIRIR
MLIRTensor MLIRTensor
MLIRMemRef MLIRMemRef
) )

mlir/lib/Dialect/Bufferization/Transforms/PassDetail.h

//===- PassDetail.h - Bufferization Pass details ----------------*- C++ -*-===// //===- PassDetail.h - Bufferization Pass details ----------------*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef DIALECT_BUFFERIZATION_TRANSFORMS_PASSDETAIL_H_ #ifndef DIALECT_BUFFERIZATION_TRANSFORMS_PASSDETAIL_H_
#define DIALECT_BUFFERIZATION_TRANSFORMS_PASSDETAIL_H_ #define DIALECT_BUFFERIZATION_TRANSFORMS_PASSDETAIL_H_
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
namespace bufferization { namespace bufferization {
class BufferizationDialect; class BufferizationDialect;
} // namespace bufferization } // namespace bufferization
Show All 14 Lines

mlir/lib/Dialect/Func/IR/FuncOps.cpp

//===- FuncOps.cpp - Func Dialect Operations ------------------------------===// //===- FuncOps.cpp - Func Dialect 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/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.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/FunctionImplementation.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/MapVector.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/Func/IR/FuncOpsDialect.cpp.inc" #include "mlir/Dialect/Func/IR/FuncOpsDialect.cpp.inc"
Show All 19 Linesstruct FuncInlinerInterface : public DialectInlinerInterface {
} }
/// All operations can be inlined. /// All operations can be inlined.
bool isLegalToInline(Operation *, Region *, bool, bool isLegalToInline(Operation *, Region *, bool,
BlockAndValueMapping &) const final { BlockAndValueMapping &) const final {
return true; return true;
} }
/// All functions can be inlined.
bool isLegalToInline(Region *, Region *, bool,
BlockAndValueMapping &) const final {
return true;
}
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Transformation Hooks // Transformation Hooks
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
/// 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, Block *newDest) const final { void handleTerminator(Operation *op, Block *newDest) const final {
// Only return needs to be handled here. // Only return needs to be handled here.
▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 Linesvoid ConstantOp::getAsmResultNames(
setNameFn(getResult(), "f"); setNameFn(getResult(), "f");
} }
bool ConstantOp::isBuildableWith(Attribute value, Type type) { bool ConstantOp::isBuildableWith(Attribute value, Type type) {
return value.isa<FlatSymbolRefAttr>() && type.isa<FunctionType>(); return value.isa<FlatSymbolRefAttr>() && type.isa<FunctionType>();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// FuncOp
//===----------------------------------------------------------------------===//
FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
ArrayRef<NamedAttribute> attrs) {
OpBuilder builder(location->getContext());
OperationState state(location, getOperationName());
FuncOp::build(builder, state, name, type, attrs);
return cast<FuncOp>(Operation::create(state));
}
FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
Operation::dialect_attr_range attrs) {
SmallVector<NamedAttribute, 8> attrRef(attrs);
return create(location, name, type, llvm::makeArrayRef(attrRef));
}
FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
ArrayRef<NamedAttribute> attrs,
ArrayRef<DictionaryAttr> argAttrs) {
FuncOp func = create(location, name, type, attrs);
func.setAllArgAttrs(argAttrs);
return func;
}
void FuncOp::build(OpBuilder &builder, OperationState &state, StringRef name,
FunctionType type, ArrayRef<NamedAttribute> attrs,
ArrayRef<DictionaryAttr> argAttrs) {
state.addAttribute(SymbolTable::getSymbolAttrName(),
builder.getStringAttr(name));
state.addAttribute(FunctionOpInterface::getTypeAttrName(),
TypeAttr::get(type));
state.attributes.append(attrs.begin(), attrs.end());
state.addRegion();
if (argAttrs.empty())
return;
assert(type.getNumInputs() == argAttrs.size());
function_interface_impl::addArgAndResultAttrs(builder, state, argAttrs,
/*resultAttrs=*/llvm::None);
}
ParseResult FuncOp::parse(OpAsmParser &parser, OperationState &result) {
auto buildFuncType =
[](Builder &builder, ArrayRef<Type> argTypes, ArrayRef<Type> results,
function_interface_impl::VariadicFlag,
std::string &) { return builder.getFunctionType(argTypes, results); };
return function_interface_impl::parseFunctionOp(
parser, result, /*allowVariadic=*/false, buildFuncType);
}
void FuncOp::print(OpAsmPrinter &p) {
function_interface_impl::printFunctionOp(p, *this, /*isVariadic=*/false);
}
/// Clone the internal blocks from this function into dest and all attributes
/// from this function to dest.
void FuncOp::cloneInto(FuncOp dest, BlockAndValueMapping &mapper) {
// Add the attributes of this function to dest.
llvm::MapVector<StringAttr, Attribute> newAttrMap;
for (const auto &attr : dest->getAttrs())
newAttrMap.insert({attr.getName(), attr.getValue()});
for (const auto &attr : (*this)->getAttrs())
newAttrMap.insert({attr.getName(), attr.getValue()});
auto newAttrs = llvm::to_vector(llvm::map_range(
newAttrMap, [](std::pair<StringAttr, Attribute> attrPair) {
return NamedAttribute(attrPair.first, attrPair.second);
}));
dest->setAttrs(DictionaryAttr::get(getContext(), newAttrs));
// Clone the body.
getBody().cloneInto(&dest.getBody(), mapper);
}
/// Create a deep copy of this function and all of its blocks, remapping
/// any operands that use values outside of the function using the map that is
/// provided (leaving them alone if no entry is present). Replaces references
/// to cloned sub-values with the corresponding value that is copied, and adds
/// those mappings to the mapper.
FuncOp FuncOp::clone(BlockAndValueMapping &mapper) {
// Create the new function.
FuncOp newFunc = cast<FuncOp>(getOperation()->cloneWithoutRegions());
// If the function has a body, then the user might be deleting arguments to
// the function by specifying them in the mapper. If so, we don't add the
// argument to the input type vector.
if (!isExternal()) {
FunctionType oldType = getType();
unsigned oldNumArgs = oldType.getNumInputs();
SmallVector<Type, 4> newInputs;
newInputs.reserve(oldNumArgs);
for (unsigned i = 0; i != oldNumArgs; ++i)
if (!mapper.contains(getArgument(i)))
newInputs.push_back(oldType.getInput(i));
/// If any of the arguments were dropped, update the type and drop any
/// necessary argument attributes.
if (newInputs.size() != oldNumArgs) {
newFunc.setType(FunctionType::get(oldType.getContext(), newInputs,
oldType.getResults()));
if (ArrayAttr argAttrs = getAllArgAttrs()) {
SmallVector<Attribute> newArgAttrs;
newArgAttrs.reserve(newInputs.size());
for (unsigned i = 0; i != oldNumArgs; ++i)
if (!mapper.contains(getArgument(i)))
newArgAttrs.push_back(argAttrs[i]);
newFunc.setAllArgAttrs(newArgAttrs);
}
}
}
/// Clone the current function into the new one and return it.
cloneInto(newFunc, mapper);
return newFunc;
}
FuncOp FuncOp::clone() {
BlockAndValueMapping mapper;
return clone(mapper);
}
//===----------------------------------------------------------------------===//
// ReturnOp // ReturnOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
LogicalResult ReturnOp::verify() { LogicalResult ReturnOp::verify() {
auto function = cast<FuncOp>((*this)->getParentOp()); auto function = cast<FuncOp>((*this)->getParentOp());
// The operand number and types must match the function signature. // The operand number and types must match the function signature.
const auto &results = function.getType().getResults(); const auto &results = function.getType().getResults();
Show All 22 Lines

mlir/lib/Dialect/Func/Transforms/FuncBufferize.cpp

//===- Bufferize.cpp - Bufferization for func ops -------------------------===// //===- Bufferize.cpp - Bufferization for func ops -------------------------===//
// //
// 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 bufferization of builtin.func's and func.call's. // This file implements bufferization of func.func's and func.call's.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PassDetail.h" #include "PassDetail.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h" #include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Func/Transforms/FuncConversions.h" #include "mlir/Dialect/Func/Transforms/FuncConversions.h"
▲ Show 20 Lines • Show All 48 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/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/DLTI/DLTI.h" #include "mlir/Dialect/DLTI/DLTI.h"
#include "mlir/Dialect/Func/IR/FuncOps.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/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/SymbolTable.h" #include "mlir/IR/SymbolTable.h"
▲ Show 20 Lines • Show All 363 Lines • Show Last 20 Lines

mlir/lib/Dialect/GPU/Transforms/PassDetail.h

//===- PassDetail.h - GPU Pass class details --------------------*- C++ -*-===// //===- PassDetail.h - GPU Pass class details --------------------*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef DIALECT_GPU_TRANSFORMS_PASSDETAIL_H_ #ifndef DIALECT_GPU_TRANSFORMS_PASSDETAIL_H_
#define DIALECT_GPU_TRANSFORMS_PASSDETAIL_H_ #define DIALECT_GPU_TRANSFORMS_PASSDETAIL_H_
#include "mlir/Dialect/Async/IR/Async.h" #include "mlir/Dialect/Async/IR/Async.h"
#include "mlir/Dialect/DLTI/DLTI.h" #include "mlir/Dialect/DLTI/DLTI.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
#define GEN_PASS_CLASSES #define GEN_PASS_CLASSES
#include "mlir/Dialect/GPU/Passes.h.inc" #include "mlir/Dialect/GPU/Passes.h.inc"
} // namespace mlir } // namespace mlir
#endif // DIALECT_GPU_TRANSFORMS_PASSDETAIL_H_ #endif // DIALECT_GPU_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/Linalg/Analysis/DependenceAnalysis.cpp

//===- DependenceAnalysis.cpp - Dependence analysis on SSA views ----------===// //===- DependenceAnalysis.cpp - Dependence analysis on SSA views ----------===//
// //
// 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 view-based alias and dependence analyses. // This file implements view-based alias and dependence analyses.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h" #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#define DEBUG_TYPE "linalg-dependence-analysis" #define DEBUG_TYPE "linalg-dependence-analysis"
▲ Show 20 Lines • Show All 333 Lines • Show Last 20 Lines

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

//===- HoistPadding.cpp - Hoisting for tensor::PadOp ----------------------===// //===- HoistPadding.cpp - Hoisting for tensor::PadOp ----------------------===//
// //
// 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 functions concerned with hoisting padding operations. // This file implements functions concerned with hoisting padding operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/Transforms/HoistPadding.h" #include "mlir/Dialect/Linalg/Transforms/HoistPadding.h"
#include "mlir/Analysis/SliceAnalysis.h" #include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Dialect/SCF/Utils/Utils.h" #include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Utils/IndexingUtils.h" #include "mlir/Dialect/Utils/IndexingUtils.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h" #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
▲ Show 20 Lines • Show All 534 Lines • Show Last 20 Lines

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

Show All 9 Lines
// in the context of Linalg transformations. // in the context of Linalg transformations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/Transforms/Hoisting.h" #include "mlir/Dialect/Linalg/Transforms/Hoisting.h"
#include "mlir/Analysis/SliceAnalysis.h" #include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineStructures.h" #include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h" #include "mlir/Dialect/Affine/IR/AffineValueMap.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Dialect/SCF/Utils/Utils.h" #include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h" #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
▲ Show 20 Lines • Show All 485 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 356 Lines • ▼ Show 20 Lines void runOnOperation() override {
}); });
if (options.hoistRedundantVectorTransfers) if (options.hoistRedundantVectorTransfers)
hoistRedundantVectorTransfers(funcOp); hoistRedundantVectorTransfers(funcOp);
if (options.hoistRedundantVectorTransfersOnTensor) if (options.hoistRedundantVectorTransfersOnTensor)
hoistRedundantVectorTransfersOnTensor(funcOp); hoistRedundantVectorTransfersOnTensor(funcOp);
// Run CSE to cleanup after canonicalization. // Run CSE to cleanup after canonicalization.
OpPassManager dynamicPM("builtin.func"); OpPassManager dynamicPM("func.func");
dynamicPM.addPass(createCSEPass()); dynamicPM.addPass(createCSEPass());
if (failed(runPipeline(dynamicPM, funcOp))) if (failed(runPipeline(dynamicPM, funcOp)))
return signalPassFailure(); return signalPassFailure();
} }
LinalgEnablingOptions options; LinalgEnablingOptions options;
LinalgTransformationFilter filter; LinalgTransformationFilter filter;
}; };
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/Transforms/PassDetail.h

//===- PassDetail.h - Linalg Pass class details -----------------*- C++ -*-===// //===- PassDetail.h - Linalg Pass class details -----------------*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef DIALECT_LINALG_TRANSFORMS_PASSDETAIL_H_ #ifndef DIALECT_LINALG_TRANSFORMS_PASSDETAIL_H_
#define DIALECT_LINALG_TRANSFORMS_PASSDETAIL_H_ #define DIALECT_LINALG_TRANSFORMS_PASSDETAIL_H_
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
namespace arith { namespace arith {
class ArithmeticDialect; class ArithmeticDialect;
} // namespace arith } // namespace arith
Show All 30 Lines

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

//===- Transforms.cpp - Linalg transformations as patterns ----------------===// //===- Transforms.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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements logic and helpers to expose Linalg transforms as rewrite // This file implements logic and helpers to expose Linalg transforms as rewrite
// patterns. // patterns.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h" #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/HoistPadding.h" #include "mlir/Dialect/Linalg/Transforms/HoistPadding.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/SCF/Transforms.h" #include "mlir/Dialect/SCF/Transforms.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tensor/IR/TensorTilingInterfaceImpl.h" #include "mlir/Dialect/Tensor/IR/TensorTilingInterfaceImpl.h"
#include "mlir/Dialect/Utils/StaticValueUtils.h" #include "mlir/Dialect/Utils/StaticValueUtils.h"
▲ Show 20 Lines • Show All 1,087 Lines • Show Last 20 Lines

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

add_mlir_dialect_library(MLIRQuantTransforms add_mlir_dialect_library(MLIRQuantTransforms
ConvertConst.cpp ConvertConst.cpp
ConvertSimQuant.cpp ConvertSimQuant.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/QuantOps/Transforms ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/QuantOps/Transforms
DEPENDS DEPENDS
MLIRQuantPassIncGen MLIRQuantPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmetic MLIRArithmetic
MLIRFunc
MLIRIR MLIRIR
MLIRQuant MLIRQuant
MLIRQuantUtils MLIRQuantUtils
MLIRPass MLIRPass
MLIRSupport MLIRSupport
MLIRTransformUtils MLIRTransformUtils
) )

mlir/lib/Dialect/Quant/Transforms/PassDetail.h

//===- PassDetail.h - Quant Pass class details ------------------*- C++ -*-===// //===- PassDetail.h - Quant Pass class details ------------------*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef DIALECT_QUANT_TRANSFORMS_PASSDETAIL_H_ #ifndef DIALECT_QUANT_TRANSFORMS_PASSDETAIL_H_
#define DIALECT_QUANT_TRANSFORMS_PASSDETAIL_H_ #define DIALECT_QUANT_TRANSFORMS_PASSDETAIL_H_
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
#define GEN_PASS_CLASSES #define GEN_PASS_CLASSES
#include "mlir/Dialect/Quant/Passes.h.inc" #include "mlir/Dialect/Quant/Passes.h.inc"
} // namespace mlir } // namespace mlir
#endif // DIALECT_QUANT_TRANSFORMS_PASSDETAIL_H_ #endif // DIALECT_QUANT_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/SCF/Transforms/PassDetail.h

//===- PassDetail.h - Loop Pass class details -------------------*- C++ -*-===// //===- PassDetail.h - Loop Pass class details -------------------*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef DIALECT_LOOPOPS_TRANSFORMS_PASSDETAIL_H_ #ifndef DIALECT_SCF_TRANSFORMS_PASSDETAIL_H_
#define DIALECT_LOOPOPS_TRANSFORMS_PASSDETAIL_H_ #define DIALECT_SCF_TRANSFORMS_PASSDETAIL_H_
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
// Forward declaration from Dialect.h // Forward declaration from Dialect.h
template <typename ConcreteDialect> template <typename ConcreteDialect>
void registerDialect(DialectRegistry &registry); void registerDialect(DialectRegistry &registry);
class AffineDialect; class AffineDialect;
Show All 14 Lines
class TensorDialect; class TensorDialect;
} // namespace tensor } // namespace tensor
#define GEN_PASS_CLASSES #define GEN_PASS_CLASSES
#include "mlir/Dialect/SCF/Passes.h.inc" #include "mlir/Dialect/SCF/Passes.h.inc"
} // namespace mlir } // namespace mlir
#endif // DIALECT_LOOPOPS_TRANSFORMS_PASSDETAIL_H_ #endif // DIALECT_SCF_TRANSFORMS_PASSDETAIL_H_

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

Show All 9 Lines
add_mlir_dialect_library(MLIRSPIRVConversion add_mlir_dialect_library(MLIRSPIRVConversion
SPIRVConversion.cpp SPIRVConversion.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRFunc
MLIRSPIRV MLIRSPIRV
MLIRTransformUtils MLIRTransformUtils
) )
add_mlir_dialect_library(MLIRSPIRVTransforms add_mlir_dialect_library(MLIRSPIRVTransforms
CanonicalizeGLSLPass.cpp CanonicalizeGLSLPass.cpp
DecorateCompositeTypeLayoutPass.cpp DecorateCompositeTypeLayoutPass.cpp
LowerABIAttributesPass.cpp LowerABIAttributesPass.cpp
Show All 15 Lines

mlir/lib/Dialect/SPIRV/Transforms/DecorateCompositeTypeLayoutPass.cpp

//===- DecorateCompositeTypeLayoutPass.cpp - Decorate composite type ------===// //===- DecorateCompositeTypeLayoutPass.cpp - Decorate composite type ------===//
// //
// 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 decorate the composite types used by // This file implements a pass to decorate the composite types used by
// composite objects in the StorageBuffer, PhysicalStorageBuffer, Uniform, and // composite objects in the StorageBuffer, PhysicalStorageBuffer, Uniform, and
// PushConstant storage classes with layout information. See SPIR-V spec // PushConstant storage classes with layout information. See SPIR-V spec
// "2.16.2. Validation Rules for Shader Capabilities" for more details. // "2.16.2. Validation Rules for Shader Capabilities" for more details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PassDetail.h" #include "PassDetail.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/Transforms/Passes.h" #include "mlir/Dialect/SPIRV/Transforms/Passes.h"
#include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h" #include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp

//===- SPIRVConversion.cpp - SPIR-V Conversion Utilities ------------------===// //===- SPIRVConversion.cpp - SPIR-V Conversion Utilities ------------------===//
// //
// 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 utilities used to lower to SPIR-V dialect. // This file implements utilities used to lower to SPIR-V dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/Sequence.h" #include "llvm/ADT/Sequence.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include <functional> #include <functional>
▲ Show 20 Lines • Show All 893 Lines • Show Last 20 Lines

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

Show All 10 Linesadd_mlir_dialect_library(MLIRShape
DEPENDS DEPENDS
MLIRShapeOpsIncGen MLIRShapeOpsIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmetic MLIRArithmetic
MLIRCastInterfaces MLIRCastInterfaces
MLIRControlFlowInterfaces MLIRControlFlowInterfaces
MLIRDialect MLIRDialect
MLIRFunc
MLIRInferTypeOpInterface MLIRInferTypeOpInterface
MLIRIR MLIRIR
MLIRSideEffectInterfaces MLIRSideEffectInterfaces
MLIRTensor MLIRTensor
) )

mlir/lib/Dialect/Shape/Transforms/PassDetail.h

//===- PassDetail.h - Shape Pass class details ------------------*- C++ -*-===// //===- PassDetail.h - Shape Pass class details ------------------*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef DIALECT_SHAPE_TRANSFORMS_PASSDETAIL_H_ #ifndef DIALECT_SHAPE_TRANSFORMS_PASSDETAIL_H_
#define DIALECT_SHAPE_TRANSFORMS_PASSDETAIL_H_ #define DIALECT_SHAPE_TRANSFORMS_PASSDETAIL_H_
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
namespace bufferization { namespace bufferization {
class BufferizationDialect; class BufferizationDialect;
} // namespace bufferization } // namespace bufferization
Show All 10 Lines

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

//===- SparseTensorPipelines.cpp - Pipelines for sparse tensor code -------===// //===- SparseTensorPipelines.cpp - Pipelines for sparse tensor code -------===//
// //
// 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/SparseTensor/Pipelines/Passes.h" #include "mlir/Dialect/SparseTensor/Pipelines/Passes.h"
#include "mlir/Conversion/Passes.h" #include "mlir/Conversion/Passes.h"
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h" #include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
#include "mlir/Dialect/Bufferization/Transforms/Passes.h" #include "mlir/Dialect/Bufferization/Transforms/Passes.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Func/Transforms/Passes.h" #include "mlir/Dialect/Func/Transforms/Passes.h"
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h" #include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
#include "mlir/Dialect/SparseTensor/Transforms/Passes.h" #include "mlir/Dialect/SparseTensor/Transforms/Passes.h"
#include "mlir/Dialect/Tensor/Transforms/Passes.h" #include "mlir/Dialect/Tensor/Transforms/Passes.h"
#include "mlir/Dialect/Vector/Transforms/Passes.h" #include "mlir/Dialect/Vector/Transforms/Passes.h"
#include "mlir/Pass/PassManager.h" #include "mlir/Pass/PassManager.h"
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CodegenUtils.h" #include "CodegenUtils.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/Bufferization/IR/BufferizableOpInterface.h" #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h" #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.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/SCF/Transforms.h" #include "mlir/Dialect/SCF/Transforms.h"
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h" #include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
#include "mlir/Dialect/SparseTensor/Transforms/Passes.h" #include "mlir/Dialect/SparseTensor/Transforms/Passes.h"
#include "mlir/Dialect/SparseTensor/Utils/Merger.h" #include "mlir/Dialect/SparseTensor/Utils/Merger.h"
▲ Show 20 Lines • Show All 1,678 Lines • Show Last 20 Lines

mlir/lib/Dialect/Tensor/Transforms/PassDetail.h

//===- PassDetail.h - GPU Pass class details --------------------*- C++ -*-===// //===- PassDetail.h - GPU Pass class details --------------------*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef DIALECT_TENSOR_TRANSFORMS_PASSDETAIL_H_ #ifndef DIALECT_TENSOR_TRANSFORMS_PASSDETAIL_H_
#define DIALECT_TENSOR_TRANSFORMS_PASSDETAIL_H_ #define DIALECT_TENSOR_TRANSFORMS_PASSDETAIL_H_
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
namespace bufferization { namespace bufferization {
class BufferizationDialect; class BufferizationDialect;
} // namespace bufferization } // namespace bufferization
Show All 14 Lines

mlir/lib/Dialect/Vector/Transforms/PassDetail.h

//===- PassDetail.h - Vector Pass class details -----------------*- C++ -*-===// //===- PassDetail.h - Vector Pass class details -----------------*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef DIALECT_VECTOR_TRANSFORMS_PASSDETAIL_H_ #ifndef DIALECT_VECTOR_TRANSFORMS_PASSDETAIL_H_
#define DIALECT_VECTOR_TRANSFORMS_PASSDETAIL_H_ #define DIALECT_VECTOR_TRANSFORMS_PASSDETAIL_H_
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
namespace bufferization { namespace bufferization {
class BufferizationDialect; class BufferizationDialect;
} // namespace bufferization } // namespace bufferization
Show All 10 Lines

mlir/lib/IR/BuiltinDialect.cpp

Show All 10 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/IR/BuiltinDialect.h" #include "mlir/IR/BuiltinDialect.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/FunctionImplementation.h"
#include "mlir/IR/OpImplementation.h" #include "mlir/IR/OpImplementation.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "llvm/ADT/MapVector.h"
using namespace mlir; using namespace mlir;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Builtin Dialect // Builtin Dialect
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/IR/BuiltinDialect.cpp.inc" #include "mlir/IR/BuiltinDialect.cpp.inc"
Show All 37 Linesvoid BuiltinDialect::initialize() {
addOperations< addOperations<
#define GET_OP_LIST #define GET_OP_LIST
#include "mlir/IR/BuiltinOps.cpp.inc" #include "mlir/IR/BuiltinOps.cpp.inc"
>(); >();
addInterfaces<BuiltinOpAsmDialectInterface>(); addInterfaces<BuiltinOpAsmDialectInterface>();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// FuncOp
//===----------------------------------------------------------------------===//
FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
ArrayRef<NamedAttribute> attrs) {
OpBuilder builder(location->getContext());
OperationState state(location, getOperationName());
FuncOp::build(builder, state, name, type, attrs);
return cast<FuncOp>(Operation::create(state));
}
FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
Operation::dialect_attr_range attrs) {
SmallVector<NamedAttribute, 8> attrRef(attrs);
return create(location, name, type, llvm::makeArrayRef(attrRef));
}
FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
ArrayRef<NamedAttribute> attrs,
ArrayRef<DictionaryAttr> argAttrs) {
FuncOp func = create(location, name, type, attrs);
func.setAllArgAttrs(argAttrs);
return func;
}
void FuncOp::build(OpBuilder &builder, OperationState &state, StringRef name,
FunctionType type, ArrayRef<NamedAttribute> attrs,
ArrayRef<DictionaryAttr> argAttrs) {
state.addAttribute(SymbolTable::getSymbolAttrName(),
builder.getStringAttr(name));
state.addAttribute(function_interface_impl::getTypeAttrName(),
TypeAttr::get(type));
state.attributes.append(attrs.begin(), attrs.end());
state.addRegion();
if (argAttrs.empty())
return;
assert(type.getNumInputs() == argAttrs.size());
function_interface_impl::addArgAndResultAttrs(builder, state, argAttrs,
/*resultAttrs=*/llvm::None);
}
ParseResult FuncOp::parse(OpAsmParser &parser, OperationState &result) {
auto buildFuncType =
[](Builder &builder, ArrayRef<Type> argTypes, ArrayRef<Type> results,
function_interface_impl::VariadicFlag,
std::string &) { return builder.getFunctionType(argTypes, results); };
return function_interface_impl::parseFunctionOp(
parser, result, /*allowVariadic=*/false, buildFuncType);
}
void FuncOp::print(OpAsmPrinter &p) {
function_interface_impl::printFunctionOp(p, *this, /*isVariadic=*/false);
}
/// Clone the internal blocks from this function into dest and all attributes
/// from this function to dest.
void FuncOp::cloneInto(FuncOp dest, BlockAndValueMapping &mapper) {
// Add the attributes of this function to dest.
llvm::MapVector<StringAttr, Attribute> newAttrMap;
for (const auto &attr : dest->getAttrs())
newAttrMap.insert({attr.getName(), attr.getValue()});
for (const auto &attr : (*this)->getAttrs())
newAttrMap.insert({attr.getName(), attr.getValue()});
auto newAttrs = llvm::to_vector(llvm::map_range(
newAttrMap, [](std::pair<StringAttr, Attribute> attrPair) {
return NamedAttribute(attrPair.first, attrPair.second);
}));
dest->setAttrs(DictionaryAttr::get(getContext(), newAttrs));
// Clone the body.
getBody().cloneInto(&dest.getBody(), mapper);
}
/// Create a deep copy of this function and all of its blocks, remapping
/// any operands that use values outside of the function using the map that is
/// provided (leaving them alone if no entry is present). Replaces references
/// to cloned sub-values with the corresponding value that is copied, and adds
/// those mappings to the mapper.
FuncOp FuncOp::clone(BlockAndValueMapping &mapper) {
// Create the new function.
FuncOp newFunc = cast<FuncOp>(getOperation()->cloneWithoutRegions());
// If the function has a body, then the user might be deleting arguments to
// the function by specifying them in the mapper. If so, we don't add the
// argument to the input type vector.
if (!isExternal()) {
FunctionType oldType = getType();
unsigned oldNumArgs = oldType.getNumInputs();
SmallVector<Type, 4> newInputs;
newInputs.reserve(oldNumArgs);
for (unsigned i = 0; i != oldNumArgs; ++i)
if (!mapper.contains(getArgument(i)))
newInputs.push_back(oldType.getInput(i));
/// If any of the arguments were dropped, update the type and drop any
/// necessary argument attributes.
if (newInputs.size() != oldNumArgs) {
newFunc.setType(FunctionType::get(oldType.getContext(), newInputs,
oldType.getResults()));
if (ArrayAttr argAttrs = getAllArgAttrs()) {
SmallVector<Attribute> newArgAttrs;
newArgAttrs.reserve(newInputs.size());
for (unsigned i = 0; i != oldNumArgs; ++i)
if (!mapper.contains(getArgument(i)))
newArgAttrs.push_back(argAttrs[i]);
newFunc.setAllArgAttrs(newArgAttrs);
}
}
}
/// Clone the current function into the new one and return it.
cloneInto(newFunc, mapper);
return newFunc;
}
FuncOp FuncOp::clone() {
BlockAndValueMapping mapper;
return clone(mapper);
}
//===----------------------------------------------------------------------===//
// ModuleOp // ModuleOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void ModuleOp::build(OpBuilder &builder, OperationState &state, void ModuleOp::build(OpBuilder &builder, OperationState &state,
Optional<StringRef> name) { Optional<StringRef> name) {
state.addRegion()->emplaceBlock(); state.addRegion()->emplaceBlock();
if (name) { if (name) {
state.attributes.push_back(builder.getNamedAttr( state.attributes.push_back(builder.getNamedAttr(
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

mlir/lib/Pass/PassRegistry.cpp

Show First 20 Lines • Show All 316 Lines • ▼ Show 20 Linesprivate:
/// parameter corresponds to the raw location within the pipeline string. This /// parameter corresponds to the raw location within the pipeline string. This
/// should always return failure. /// should always return failure.
using ErrorHandlerT = function_ref<LogicalResult(const char *, Twine)>; using ErrorHandlerT = function_ref<LogicalResult(const char *, Twine)>;
/// A struct to capture parsed pass pipeline names. /// A struct to capture parsed pass pipeline names.
/// ///
/// A pipeline is defined as a series of names, each of which may in itself /// A pipeline is defined as a series of names, each of which may in itself
/// recursively contain a nested pipeline. A name is either the name of a pass /// recursively contain a nested pipeline. A name is either the name of a pass
/// (e.g. "cse") or the name of an operation type (e.g. "builtin.func"). If /// (e.g. "cse") or the name of an operation type (e.g. "buitin.module"). If
/// the name is the name of a pass, the InnerPipeline is empty, since passes /// the name is the name of a pass, the InnerPipeline is empty, since passes
/// cannot contain inner pipelines. /// cannot contain inner pipelines.
struct PipelineElement { struct PipelineElement {
PipelineElement(StringRef name) : name(name) {} PipelineElement(StringRef name) : name(name) {}
StringRef name; StringRef name;
StringRef options; StringRef options;
const PassRegistryEntry *registryEntry = nullptr; const PassRegistryEntry *registryEntry = nullptr;
▲ Show 20 Lines • Show All 487 Lines • Show Last 20 Lines

mlir/lib/Target/LLVMIR/ConvertToLLVMIR.cpp

//===- ConvertToLLVMIR.cpp - MLIR to LLVM IR conversion -------------------===// //===- ConvertToLLVMIR.cpp - MLIR to LLVM IR 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 translation between the MLIR LLVM dialect and LLVM IR. // This file implements a translation between the MLIR LLVM dialect and LLVM IR.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/DLTI/DLTI.h" #include "mlir/Dialect/DLTI/DLTI.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/Target/LLVMIR/Dialect/All.h" #include "mlir/Target/LLVMIR/Dialect/All.h"
#include "mlir/Target/LLVMIR/Export.h" #include "mlir/Target/LLVMIR/Export.h"
#include "mlir/Tools/mlir-translate/Translation.h" #include "mlir/Tools/mlir-translate/Translation.h"
#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
using namespace mlir; using namespace mlir;
namespace mlir { namespace mlir {
void registerToLLVMIRTranslation() { void registerToLLVMIRTranslation() {
TranslateFromMLIRRegistration registration( TranslateFromMLIRRegistration registration(
"mlir-to-llvmir", "mlir-to-llvmir",
[](ModuleOp module, raw_ostream &output) { [](ModuleOp module, raw_ostream &output) {
llvm::LLVMContext llvmContext; llvm::LLVMContext llvmContext;
auto llvmModule = translateModuleToLLVMIR(module, llvmContext); auto llvmModule = translateModuleToLLVMIR(module, llvmContext);
if (!llvmModule) if (!llvmModule)
return failure(); return failure();
llvmModule->print(output, nullptr); llvmModule->print(output, nullptr);
return success(); return success();
}, },
[](DialectRegistry &registry) { [](DialectRegistry &registry) {
registry.insert<DLTIDialect>(); registry.insert<DLTIDialect, func::FuncDialect>();
registerAllToLLVMIRTranslations(registry); registerAllToLLVMIRTranslations(registry);
}); });
} }
} // namespace mlir } // namespace mlir

mlir/lib/Transforms/Utils/InliningUtils.cpp

//===- InliningUtils.cpp ---- Misc utilities for inlining -----------------===// //===- InliningUtils.cpp ---- Misc utilities for inlining -----------------===//
// //
// 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 miscellaneous inlining utilities. // This file implements miscellaneous inlining utilities.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Transforms/InliningUtils.h" #include "mlir/Transforms/InliningUtils.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/Operation.h" #include "mlir/IR/Operation.h"
#include "mlir/Interfaces/CallInterfaces.h"
#include "llvm/ADT/MapVector.h" #include "llvm/ADT/MapVector.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#define DEBUG_TYPE "inlining" #define DEBUG_TYPE "inlining"
using namespace mlir; using namespace mlir;
Show All 35 Linesbool InlinerInterface::isLegalToInline(Operation *call, Operation *callable,
if (auto *handler = getInterfaceFor(call)) if (auto *handler = getInterfaceFor(call))
return handler->isLegalToInline(call, callable, wouldBeCloned); return handler->isLegalToInline(call, callable, wouldBeCloned);
return false; return false;
} }
bool InlinerInterface::isLegalToInline( bool InlinerInterface::isLegalToInline(
Region *dest, Region *src, bool wouldBeCloned, Region *dest, Region *src, bool wouldBeCloned,
BlockAndValueMapping &valueMapping) const { BlockAndValueMapping &valueMapping) const {
// Regions can always be inlined into functions.
if (isa<FuncOp>(dest->getParentOp()))
return true;
if (auto *handler = getInterfaceFor(dest->getParentOp())) if (auto *handler = getInterfaceFor(dest->getParentOp()))
return handler->isLegalToInline(dest, src, wouldBeCloned, valueMapping); return handler->isLegalToInline(dest, src, wouldBeCloned, valueMapping);
return false; return false;
} }
bool InlinerInterface::isLegalToInline( bool InlinerInterface::isLegalToInline(
Operation *op, Region *dest, bool wouldBeCloned, Operation *op, Region *dest, bool wouldBeCloned,
BlockAndValueMapping &valueMapping) const { BlockAndValueMapping &valueMapping) const {
▲ Show 20 Lines • Show All 338 Lines • Show Last 20 Lines

mlir/python/mlir/dialects/_builtin_ops_ext.py

# 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
try: try:
from typing import Optional, Sequence, Union
import inspect
from ..ir import * from ..ir import *
except ImportError as e: except ImportError as e:
raise RuntimeError("Error loading imports from extension module") from e raise RuntimeError("Error loading imports from extension module") from e
ARGUMENT_ATTRIBUTE_NAME = "arg_attrs"
RESULT_ATTRIBUTE_NAME = "res_attrs"
class ModuleOp: class ModuleOp:
"""Specialization for the module op class.""" """Specialization for the module op class."""
def __init__(self, *, loc=None, ip=None): def __init__(self, *, loc=None, ip=None):
super().__init__(self.build_generic(results=[], operands=[], loc=loc, super().__init__(self.build_generic(results=[], operands=[], loc=loc,
ip=ip)) ip=ip))
body = self.regions[0].blocks.append() body = self.regions[0].blocks.append()
@property @property
def body(self): def body(self):
return self.regions[0].blocks[0] return self.regions[0].blocks[0]
class FuncOp:
"""Specialization for the func op class."""
def __init__(self,
name,
type,
*,
visibility=None,
body_builder=None,
loc=None,
ip=None):
"""
Create a FuncOp with the provided `name`, `type`, and `visibility`.
- `name` is a string representing the function name.
- `type` is either a FunctionType or a pair of list describing inputs and
results.
- `visibility` is a string matching `public`, `private`, or `nested`. None
implies private visibility.
- `body_builder` is an optional callback, when provided a new entry block
is created and the callback is invoked with the new op as argument within
an InsertionPoint context already set for the block. The callback is
expected to insert a terminator in the block.
"""
sym_name = StringAttr.get(str(name))
# If the type is passed as a tuple, build a FunctionType on the fly.
if isinstance(type, tuple):
type = FunctionType.get(inputs=type[0], results=type[1])
type = TypeAttr.get(type)
sym_visibility = StringAttr.get(
str(visibility)) if visibility is not None else None
super().__init__(sym_name, type, sym_visibility, loc=loc, ip=ip)
if body_builder:
entry_block = self.add_entry_block()
with InsertionPoint(entry_block):
body_builder(self)
@property
def is_external(self):
return len(self.regions[0].blocks) == 0
@property
def body(self):
return self.regions[0]
@property
def type(self):
return FunctionType(TypeAttr(self.attributes["type"]).value)
@property
def visibility(self):
return self.attributes["sym_visibility"]
@property
def name(self) -> StringAttr:
return StringAttr(self.attributes["sym_name"])
@property
def entry_block(self):
if self.is_external:
raise IndexError('External function does not have a body')
return self.regions[0].blocks[0]
def add_entry_block(self):
"""
Add an entry block to the function body using the function signature to
infer block arguments.
Returns the newly created block
"""
if not self.is_external:
raise IndexError('The function already has an entry block!')
self.body.blocks.append(*self.type.inputs)
return self.body.blocks[0]
@property
def arg_attrs(self):
return ArrayAttr(self.attributes[ARGUMENT_ATTRIBUTE_NAME])
@arg_attrs.setter
def arg_attrs(self, attribute: Union[ArrayAttr, list]):
if isinstance(attribute, ArrayAttr):
self.attributes[ARGUMENT_ATTRIBUTE_NAME] = attribute
else:
self.attributes[ARGUMENT_ATTRIBUTE_NAME] = ArrayAttr.get(
attribute, context=self.context)
@property
def arguments(self):
return self.entry_block.arguments
@property
def result_attrs(self):
return self.attributes[RESULT_ATTRIBUTE_NAME]
@result_attrs.setter
def result_attrs(self, attribute: ArrayAttr):
self.attributes[RESULT_ATTRIBUTE_NAME] = attribute
@classmethod
def from_py_func(FuncOp,
*inputs: Type,
results: Optional[Sequence[Type]] = None,
name: Optional[str] = None):
"""Decorator to define an MLIR FuncOp specified as a python function.
Requires that an `mlir.ir.InsertionPoint` and `mlir.ir.Location` are
active for the current thread (i.e. established in a `with` block).
When applied as a decorator to a Python function, an entry block will
be constructed for the FuncOp with types as specified in `*inputs`. The
block arguments will be passed positionally to the Python function. In
addition, if the Python function accepts keyword arguments generally or
has a corresponding keyword argument, the following will be passed:
* `func_op`: The `func` op being defined.
By default, the function name will be the Python function `__name__`. This
can be overriden by passing the `name` argument to the decorator.
If `results` is not specified, then the decorator will implicitly
insert a `ReturnOp` with the `Value`'s returned from the decorated
function. It will also set the `FuncOp` type with the actual return
value types. If `results` is specified, then the decorated function
must return `None` and no implicit `ReturnOp` is added (nor are the result
types updated). The implicit behavior is intended for simple, single-block
cases, and users should specify result types explicitly for any complicated
cases.
The decorated function can further be called from Python and will insert
a `CallOp` at the then-current insertion point, returning either None (
if no return values), a unary Value (for one result), or a list of Values).
This mechanism cannot be used to emit recursive calls (by construction).
"""
def decorator(f):
from . import func
# Introspect the callable for optional features.
sig = inspect.signature(f)
has_arg_func_op = False
for param in sig.parameters.values():
if param.kind == param.VAR_KEYWORD:
has_arg_func_op = True
if param.name == "func_op" and (param.kind
== param.POSITIONAL_OR_KEYWORD or
param.kind == param.KEYWORD_ONLY):
has_arg_func_op = True
# Emit the FuncOp.
implicit_return = results is None
symbol_name = name or f.__name__
function_type = FunctionType.get(
inputs=inputs, results=[] if implicit_return else results)
func_op = FuncOp(name=symbol_name, type=function_type)
with InsertionPoint(func_op.add_entry_block()):
func_args = func_op.entry_block.arguments
func_kwargs = {}
if has_arg_func_op:
func_kwargs["func_op"] = func_op
return_values = f(*func_args, **func_kwargs)
if not implicit_return:
return_types = list(results)
assert return_values is None, (
"Capturing a python function with explicit `results=` "
"requires that the wrapped function returns None.")
else:
# Coerce return values, add ReturnOp and rewrite func type.
if return_values is None:
return_values = []
elif isinstance(return_values, tuple):
return_values = list(return_values)
elif isinstance(return_values, Value):
# Returning a single value is fine, coerce it into a list.
return_values = [return_values]
elif isinstance(return_values, OpView):
# Returning a single operation is fine, coerce its results a list.
return_values = return_values.operation.results
elif isinstance(return_values, Operation):
# Returning a single operation is fine, coerce its results a list.
return_values = return_values.results
else:
return_values = list(return_values)
func.ReturnOp(return_values)
# Recompute the function type.
return_types = [v.type for v in return_values]
function_type = FunctionType.get(inputs=inputs, results=return_types)
func_op.attributes["type"] = TypeAttr.get(function_type)
def emit_call_op(*call_args):
call_op = func.CallOp(return_types, FlatSymbolRefAttr.get(symbol_name),
call_args)
if return_types is None:
return None
elif len(return_types) == 1:
return call_op.result
else:
return call_op.results
wrapped = emit_call_op
wrapped.__name__ = f.__name__
wrapped.func_op = func_op
return wrapped
return decorator

mlir/python/mlir/dialects/_func_ops_ext.py

# 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
try: try:
from ..ir import * from ..ir import *
from .builtin import FuncOp
from ._ods_common import get_default_loc_context as _get_default_loc_context from ._ods_common import get_default_loc_context as _get_default_loc_context
from typing import Any, List, Optional, Union import inspect
from typing import Any, List, Optional, Sequence, Union
except ImportError as e: except ImportError as e:
raise RuntimeError("Error loading imports from extension module") from e raise RuntimeError("Error loading imports from extension module") from e
ARGUMENT_ATTRIBUTE_NAME = "arg_attrs"
RESULT_ATTRIBUTE_NAME = "res_attrs"
class ConstantOp: class ConstantOp:
"""Specialization for the constant op class.""" """Specialization for the constant op class."""
def __init__(self, result: Type, value: Attribute, *, loc=None, ip=None): def __init__(self, result: Type, value: Attribute, *, loc=None, ip=None):
super().__init__(result, value, loc=loc, ip=ip) super().__init__(result, value, loc=loc, ip=ip)
@property @property
def type(self): def type(self):
return self.results[0].type return self.results[0].type
class FuncOp:
"""Specialization for the func op class."""
def __init__(self,
name,
type,
*,
visibility=None,
body_builder=None,
loc=None,
ip=None):
"""
Create a FuncOp with the provided `name`, `type`, and `visibility`.
- `name` is a string representing the function name.
- `type` is either a FunctionType or a pair of list describing inputs and
results.
- `visibility` is a string matching `public`, `private`, or `nested`. None
implies private visibility.
- `body_builder` is an optional callback, when provided a new entry block
is created and the callback is invoked with the new op as argument within
an InsertionPoint context already set for the block. The callback is
expected to insert a terminator in the block.
"""
sym_name = StringAttr.get(str(name))
# If the type is passed as a tuple, build a FunctionType on the fly.
if isinstance(type, tuple):
type = FunctionType.get(inputs=type[0], results=type[1])
type = TypeAttr.get(type)
sym_visibility = StringAttr.get(
str(visibility)) if visibility is not None else None
super().__init__(sym_name, type, sym_visibility, loc=loc, ip=ip)
if body_builder:
entry_block = self.add_entry_block()
with InsertionPoint(entry_block):
body_builder(self)
@property
def is_external(self):
return len(self.regions[0].blocks) == 0
@property
def body(self):
return self.regions[0]
@property
def type(self):
return FunctionType(TypeAttr(self.attributes["type"]).value)
@property
def visibility(self):
return self.attributes["sym_visibility"]
@property
def name(self) -> StringAttr:
return StringAttr(self.attributes["sym_name"])
@property
def entry_block(self):
if self.is_external:
raise IndexError('External function does not have a body')
return self.regions[0].blocks[0]
def add_entry_block(self):
"""
Add an entry block to the function body using the function signature to
infer block arguments.
Returns the newly created block
"""
if not self.is_external:
raise IndexError('The function already has an entry block!')
self.body.blocks.append(*self.type.inputs)
return self.body.blocks[0]
@property
def arg_attrs(self):
return ArrayAttr(self.attributes[ARGUMENT_ATTRIBUTE_NAME])
@arg_attrs.setter
def arg_attrs(self, attribute: Union[ArrayAttr, list]):
if isinstance(attribute, ArrayAttr):
self.attributes[ARGUMENT_ATTRIBUTE_NAME] = attribute
else:
self.attributes[ARGUMENT_ATTRIBUTE_NAME] = ArrayAttr.get(
attribute, context=self.context)
@property
def arguments(self):
return self.entry_block.arguments
@property
def result_attrs(self):
return self.attributes[RESULT_ATTRIBUTE_NAME]
@result_attrs.setter
def result_attrs(self, attribute: ArrayAttr):
self.attributes[RESULT_ATTRIBUTE_NAME] = attribute
@classmethod
def from_py_func(FuncOp,
*inputs: Type,
results: Optional[Sequence[Type]] = None,
name: Optional[str] = None):
"""Decorator to define an MLIR FuncOp specified as a python function.
Requires that an `mlir.ir.InsertionPoint` and `mlir.ir.Location` are
active for the current thread (i.e. established in a `with` block).
When applied as a decorator to a Python function, an entry block will
be constructed for the FuncOp with types as specified in `*inputs`. The
block arguments will be passed positionally to the Python function. In
addition, if the Python function accepts keyword arguments generally or
has a corresponding keyword argument, the following will be passed:
* `func_op`: The `func` op being defined.
By default, the function name will be the Python function `__name__`. This
can be overriden by passing the `name` argument to the decorator.
If `results` is not specified, then the decorator will implicitly
insert a `ReturnOp` with the `Value`'s returned from the decorated
function. It will also set the `FuncOp` type with the actual return
value types. If `results` is specified, then the decorated function
must return `None` and no implicit `ReturnOp` is added (nor are the result
types updated). The implicit behavior is intended for simple, single-block
cases, and users should specify result types explicitly for any complicated
cases.
The decorated function can further be called from Python and will insert
a `CallOp` at the then-current insertion point, returning either None (
if no return values), a unary Value (for one result), or a list of Values).
This mechanism cannot be used to emit recursive calls (by construction).
"""
def decorator(f):
from . import func
# Introspect the callable for optional features.
sig = inspect.signature(f)
has_arg_func_op = False
for param in sig.parameters.values():
if param.kind == param.VAR_KEYWORD:
has_arg_func_op = True
if param.name == "func_op" and (param.kind
== param.POSITIONAL_OR_KEYWORD or
param.kind == param.KEYWORD_ONLY):
has_arg_func_op = True
# Emit the FuncOp.
implicit_return = results is None
symbol_name = name or f.__name__
function_type = FunctionType.get(
inputs=inputs, results=[] if implicit_return else results)
func_op = FuncOp(name=symbol_name, type=function_type)
with InsertionPoint(func_op.add_entry_block()):
func_args = func_op.entry_block.arguments
func_kwargs = {}
if has_arg_func_op:
func_kwargs["func_op"] = func_op
return_values = f(*func_args, **func_kwargs)
if not implicit_return:
return_types = list(results)
assert return_values is None, (
"Capturing a python function with explicit `results=` "
"requires that the wrapped function returns None.")
else:
# Coerce return values, add ReturnOp and rewrite func type.
if return_values is None:
return_values = []
elif isinstance(return_values, tuple):
return_values = list(return_values)
elif isinstance(return_values, Value):
# Returning a single value is fine, coerce it into a list.
return_values = [return_values]
elif isinstance(return_values, OpView):
# Returning a single operation is fine, coerce its results a list.
return_values = return_values.operation.results
elif isinstance(return_values, Operation):
# Returning a single operation is fine, coerce its results a list.
return_values = return_values.results
else:
return_values = list(return_values)
func.ReturnOp(return_values)
# Recompute the function type.
return_types = [v.type for v in return_values]
function_type = FunctionType.get(inputs=inputs, results=return_types)
func_op.attributes["type"] = TypeAttr.get(function_type)
def emit_call_op(*call_args):
call_op = func.CallOp(return_types, FlatSymbolRefAttr.get(symbol_name),
call_args)
if return_types is None:
return None
elif len(return_types) == 1:
return call_op.result
else:
return call_op.results
wrapped = emit_call_op
wrapped.__name__ = f.__name__
wrapped.func_op = func_op
return wrapped
return decorator
class CallOp: class CallOp:
"""Specialization for the call op class.""" """Specialization for the call op class."""
def __init__(self, def __init__(self,
calleeOrResults: Union[FuncOp, List[Type]], calleeOrResults: Union[FuncOp, List[Type]],
argumentsOrCallee: Union[List, FlatSymbolRefAttr, str], argumentsOrCallee: Union[List, FlatSymbolRefAttr, str],
arguments: Optional[List] = None, arguments: Optional[List] = None,
*, *,
loc=None, loc=None,
ip=None): ip=None):
"""Creates an call operation. """Creates an call operation.
The constructor accepts three different forms: The constructor accepts three different forms:
1. A function op to be called followed by a list of arguments. 1. A function op to be called followed by a list of arguments.
2. A list of result types, followed by the name of the function to be 2. A list of result types, followed by the name of the function to be
called as string, following by a list of arguments. called as string, following by a list of arguments.
3. A list of result types, followed by the name of the function to be 3. A list of result types, followed by the name of the function to be
called as symbol reference attribute, followed by a list of arguments. called as symbol reference attribute, followed by a list of arguments.
For example For example
f = builtin.FuncOp("foo", ...) f = func.FuncOp("foo", ...)
func.CallOp(f, [args]) func.CallOp(f, [args])
func.CallOp([result_types], "foo", [args]) func.CallOp([result_types], "foo", [args])
In all cases, the location and insertion point may be specified as keyword In all cases, the location and insertion point may be specified as keyword
arguments if not provided by the surrounding context managers. arguments if not provided by the surrounding context managers.
""" """
# TODO: consider supporting constructor "overloads", e.g., through a custom # TODO: consider supporting constructor "overloads", e.g., through a custom
Show All 37 Lines

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

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

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

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

mlir/test/Analysis/test-dominance.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.func(test-print-dominance)" -split-input-file 2>&1 | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="func.func(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) {
cf.cond_br %cond, ^bb1, ^bb2 cf.cond_br %cond, ^bb1, ^bb2
^bb1: ^bb1:
cf.br ^exit cf.br ^exit
^bb2: ^bb2:
cf.br ^exit cf.br ^exit
▲ Show 20 Lines • Show All 298 Lines • Show Last 20 Lines

mlir/test/Analysis/test-liveness.mlir

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

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

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

mlir/test/Analysis/test-shape-fn-report.mlir

Show All 9 Linesfunc @tanh(%arg: tensor<10x20xf32>) -> tensor<10x20xf32>
// expected-remark@+1 {{associated shape function: same_result_shape}} // expected-remark@+1 {{associated shape function: same_result_shape}}
%1 = "test.same_operand_result_type"(%0) : (tensor<10x20xf32>) -> tensor<10x20xf32> %1 = "test.same_operand_result_type"(%0) : (tensor<10x20xf32>) -> tensor<10x20xf32>
return %1 : tensor<10x20xf32> return %1 : tensor<10x20xf32>
} }
// The shape function library with some local functions. // The shape function library with some local functions.
shape.function_library @shape_lib { shape.function_library @shape_lib {
// Test shape function that returns the shape of input arg as result shape. // Test shape function that returns the shape of input arg as result shape.
builtin.func @same_result_shape(%arg: !shape.value_shape) -> !shape.shape { func.func @same_result_shape(%arg: !shape.value_shape) -> !shape.shape {
%0 = shape.shape_of %arg : !shape.value_shape -> !shape.shape %0 = shape.shape_of %arg : !shape.value_shape -> !shape.shape
return %0 : !shape.shape return %0 : !shape.shape
} }
} mapping { } mapping {
test.same_operand_result_type = @same_result_shape test.same_operand_result_type = @same_result_shape
} }
} }

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

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

mlir/test/CAPI/execution_engine.c

Show All 20 Lines
#include <math.h> #include <math.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
void lowerModuleToLLVM(MlirContext ctx, MlirModule module) { void lowerModuleToLLVM(MlirContext ctx, MlirModule module) {
MlirPassManager pm = mlirPassManagerCreate(ctx); MlirPassManager pm = mlirPassManagerCreate(ctx);
MlirOpPassManager opm = mlirPassManagerGetNestedUnder( MlirOpPassManager opm = mlirPassManagerGetNestedUnder(
pm, mlirStringRefCreateFromCString("builtin.func")); pm, mlirStringRefCreateFromCString("func.func"));
mlirPassManagerAddOwnedPass(pm, mlirCreateConversionConvertFuncToLLVM()); mlirPassManagerAddOwnedPass(pm, mlirCreateConversionConvertFuncToLLVM());
mlirOpPassManagerAddOwnedPass(opm, mlirOpPassManagerAddOwnedPass(opm,
mlirCreateConversionConvertArithmeticToLLVM()); mlirCreateConversionConvertArithmeticToLLVM());
MlirLogicalResult status = mlirPassManagerRun(pm, module); MlirLogicalResult status = mlirPassManagerRun(pm, module);
if (mlirLogicalResultIsFailure(status)) { if (mlirLogicalResultIsFailure(status)) {
fprintf(stderr, "Unexpected failure running pass pipeline\n"); fprintf(stderr, "Unexpected failure running pass pipeline\n");
exit(2); exit(2);
} }
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

mlir/test/CAPI/ir.c

Show First 20 Lines • Show All 95 Lines • ▼ Show 20 LinesMlirModule makeAndDumpAdd(MlirContext ctx, MlirLocation location) {
MlirNamedAttribute funcAttrs[] = { MlirNamedAttribute funcAttrs[] = {
mlirNamedAttributeGet( mlirNamedAttributeGet(
mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("type")), mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("type")),
funcTypeAttr), funcTypeAttr),
mlirNamedAttributeGet( mlirNamedAttributeGet(
mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("sym_name")), mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("sym_name")),
funcNameAttr)}; funcNameAttr)};
MlirOperationState funcState = mlirOperationStateGet( MlirOperationState funcState = mlirOperationStateGet(
mlirStringRefCreateFromCString("builtin.func"), location); mlirStringRefCreateFromCString("func.func"), location);
mlirOperationStateAddAttributes(&funcState, 2, funcAttrs); mlirOperationStateAddAttributes(&funcState, 2, funcAttrs);
mlirOperationStateAddOwnedRegions(&funcState, 1, &funcBodyRegion); mlirOperationStateAddOwnedRegions(&funcState, 1, &funcBodyRegion);
MlirOperation func = mlirOperationCreate(&funcState); MlirOperation func = mlirOperationCreate(&funcState);
mlirBlockInsertOwnedOperation(moduleBody, 0, func); mlirBlockInsertOwnedOperation(moduleBody, 0, func);
MlirType indexType = MlirType indexType =
mlirTypeParseGet(ctx, mlirStringRefCreateFromCString("index")); mlirTypeParseGet(ctx, mlirStringRefCreateFromCString("index"));
MlirAttribute indexZeroLiteral = MlirAttribute indexZeroLiteral =
▲ Show 20 Lines • Show All 1,926 Lines • Show Last 20 Lines

mlir/test/CAPI/pass.c

Show All 36 Lines"}"));
if (mlirModuleIsNull(module)) { if (mlirModuleIsNull(module)) {
fprintf(stderr, "Unexpected failure parsing module.\n"); fprintf(stderr, "Unexpected failure parsing module.\n");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// Run the print-op-stats pass on the top-level module: // Run the print-op-stats pass on the top-level module:
// CHECK-LABEL: Operations encountered: // CHECK-LABEL: Operations encountered:
// CHECK: arith.addi , 1 // CHECK: arith.addi , 1
// CHECK: builtin.func , 1 // CHECK: func.func , 1
// CHECK: func.return , 1 // CHECK: func.return , 1
{ {
MlirPassManager pm = mlirPassManagerCreate(ctx); MlirPassManager pm = mlirPassManagerCreate(ctx);
MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats(); MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
mlirPassManagerAddOwnedPass(pm, printOpStatPass); mlirPassManagerAddOwnedPass(pm, printOpStatPass);
MlirLogicalResult success = mlirPassManagerRun(pm, module); MlirLogicalResult success = mlirPassManagerRun(pm, module);
if (mlirLogicalResultIsFailure(success)) { if (mlirLogicalResultIsFailure(success)) {
fprintf(stderr, "Unexpected failure running pass manager.\n"); fprintf(stderr, "Unexpected failure running pass manager.\n");
Show All 25 Lines
"}")); "}"));
// clang-format on // clang-format on
if (mlirModuleIsNull(module)) if (mlirModuleIsNull(module))
exit(1); exit(1);
// Run the print-op-stats pass on functions under the top-level module: // Run the print-op-stats pass on functions under the top-level module:
// CHECK-LABEL: Operations encountered: // CHECK-LABEL: Operations encountered:
// CHECK: arith.addi , 1 // CHECK: arith.addi , 1
// CHECK: builtin.func , 1 // CHECK: func.func , 1
// CHECK: func.return , 1 // CHECK: func.return , 1
{ {
MlirPassManager pm = mlirPassManagerCreate(ctx); MlirPassManager pm = mlirPassManagerCreate(ctx);
MlirOpPassManager nestedFuncPm = mlirPassManagerGetNestedUnder( MlirOpPassManager nestedFuncPm = mlirPassManagerGetNestedUnder(
pm, mlirStringRefCreateFromCString("builtin.func")); pm, mlirStringRefCreateFromCString("func.func"));
MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats(); MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass); mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass);
MlirLogicalResult success = mlirPassManagerRun(pm, module); MlirLogicalResult success = mlirPassManagerRun(pm, module);
if (mlirLogicalResultIsFailure(success)) if (mlirLogicalResultIsFailure(success))
exit(2); exit(2);
mlirPassManagerDestroy(pm); mlirPassManagerDestroy(pm);
} }
// Run the print-op-stats pass on functions under the nested module: // Run the print-op-stats pass on functions under the nested module:
// CHECK-LABEL: Operations encountered: // CHECK-LABEL: Operations encountered:
// CHECK: arith.addf , 1 // CHECK: arith.addf , 1
// CHECK: builtin.func , 1 // CHECK: func.func , 1
// CHECK: func.return , 1 // CHECK: func.return , 1
{ {
MlirPassManager pm = mlirPassManagerCreate(ctx); MlirPassManager pm = mlirPassManagerCreate(ctx);
MlirOpPassManager nestedModulePm = mlirPassManagerGetNestedUnder( MlirOpPassManager nestedModulePm = mlirPassManagerGetNestedUnder(
pm, mlirStringRefCreateFromCString("builtin.module")); pm, mlirStringRefCreateFromCString("builtin.module"));
MlirOpPassManager nestedFuncPm = mlirOpPassManagerGetNestedUnder( MlirOpPassManager nestedFuncPm = mlirOpPassManagerGetNestedUnder(
nestedModulePm, mlirStringRefCreateFromCString("builtin.func")); nestedModulePm, mlirStringRefCreateFromCString("func.func"));
MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats(); MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass); mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass);
MlirLogicalResult success = mlirPassManagerRun(pm, module); MlirLogicalResult success = mlirPassManagerRun(pm, module);
if (mlirLogicalResultIsFailure(success)) if (mlirLogicalResultIsFailure(success))
exit(2); exit(2);
mlirPassManagerDestroy(pm); mlirPassManagerDestroy(pm);
} }
mlirModuleDestroy(module); mlirModuleDestroy(module);
mlirContextDestroy(ctx); mlirContextDestroy(ctx);
} }
static void printToStderr(MlirStringRef str, void *userData) { static void printToStderr(MlirStringRef str, void *userData) {
(void)userData; (void)userData;
fwrite(str.data, 1, str.length, stderr); fwrite(str.data, 1, str.length, stderr);
} }
void testPrintPassPipeline() { void testPrintPassPipeline() {
MlirContext ctx = mlirContextCreate(); MlirContext ctx = mlirContextCreate();
MlirPassManager pm = mlirPassManagerCreate(ctx); MlirPassManager pm = mlirPassManagerCreate(ctx);
// Populate the pass-manager // Populate the pass-manager
MlirOpPassManager nestedModulePm = mlirPassManagerGetNestedUnder( MlirOpPassManager nestedModulePm = mlirPassManagerGetNestedUnder(
pm, mlirStringRefCreateFromCString("builtin.module")); pm, mlirStringRefCreateFromCString("builtin.module"));
MlirOpPassManager nestedFuncPm = mlirOpPassManagerGetNestedUnder( MlirOpPassManager nestedFuncPm = mlirOpPassManagerGetNestedUnder(
nestedModulePm, mlirStringRefCreateFromCString("builtin.func")); nestedModulePm, mlirStringRefCreateFromCString("func.func"));
MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats(); MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass); mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass);
// Print the top level pass manager // Print the top level pass manager
// CHECK: Top-level: builtin.module(builtin.func(print-op-stats)) // CHECK: Top-level: builtin.module(func.func(print-op-stats))
fprintf(stderr, "Top-level: "); fprintf(stderr, "Top-level: ");
mlirPrintPassPipeline(mlirPassManagerGetAsOpPassManager(pm), printToStderr, mlirPrintPassPipeline(mlirPassManagerGetAsOpPassManager(pm), printToStderr,
NULL); NULL);
fprintf(stderr, "\n"); fprintf(stderr, "\n");
// Print the pipeline nested one level down // Print the pipeline nested one level down
// CHECK: Nested Module: builtin.func(print-op-stats) // CHECK: Nested Module: func.func(print-op-stats)
fprintf(stderr, "Nested Module: "); fprintf(stderr, "Nested Module: ");
mlirPrintPassPipeline(nestedModulePm, printToStderr, NULL); mlirPrintPassPipeline(nestedModulePm, printToStderr, NULL);
fprintf(stderr, "\n"); fprintf(stderr, "\n");
// Print the pipeline nested two levels down // Print the pipeline nested two levels down
// CHECK: Nested Module>Func: print-op-stats // CHECK: Nested Module>Func: print-op-stats
fprintf(stderr, "Nested Module>Func: "); fprintf(stderr, "Nested Module>Func: ");
mlirPrintPassPipeline(nestedFuncPm, printToStderr, NULL); mlirPrintPassPipeline(nestedFuncPm, printToStderr, NULL);
fprintf(stderr, "\n"); fprintf(stderr, "\n");
mlirPassManagerDestroy(pm); mlirPassManagerDestroy(pm);
mlirContextDestroy(ctx); mlirContextDestroy(ctx);
} }
void testParsePassPipeline() { void testParsePassPipeline() {
MlirContext ctx = mlirContextCreate(); MlirContext ctx = mlirContextCreate();
MlirPassManager pm = mlirPassManagerCreate(ctx); MlirPassManager pm = mlirPassManagerCreate(ctx);
// Try parse a pipeline. // Try parse a pipeline.
MlirLogicalResult status = mlirParsePassPipeline( MlirLogicalResult status = mlirParsePassPipeline(
mlirPassManagerGetAsOpPassManager(pm), mlirPassManagerGetAsOpPassManager(pm),
mlirStringRefCreateFromCString( mlirStringRefCreateFromCString("builtin.module(func.func(print-op-stats),"
"builtin.module(builtin.func(print-op-stats), builtin.func(print-op-stats))")); " func.func(print-op-stats))"));
// Expect a failure, we haven't registered the print-op-stats pass yet. // Expect a failure, we haven't registered the print-op-stats pass yet.
if (mlirLogicalResultIsSuccess(status)) { if (mlirLogicalResultIsSuccess(status)) {
fprintf(stderr, "Unexpected success parsing pipeline without registering the pass\n"); fprintf(stderr, "Unexpected success parsing pipeline without registering the pass\n");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// Try again after registrating the pass. // Try again after registrating the pass.
mlirRegisterTransformsPrintOpStats(); mlirRegisterTransformsPrintOpStats();
status = mlirParsePassPipeline( status = mlirParsePassPipeline(
mlirPassManagerGetAsOpPassManager(pm), mlirPassManagerGetAsOpPassManager(pm),
mlirStringRefCreateFromCString( mlirStringRefCreateFromCString("builtin.module(func.func(print-op-stats),"
"builtin.module(builtin.func(print-op-stats), builtin.func(print-op-stats))")); " func.func(print-op-stats))"));
// Expect a failure, we haven't registered the print-op-stats pass yet. // Expect a failure, we haven't registered the print-op-stats pass yet.
if (mlirLogicalResultIsFailure(status)) { if (mlirLogicalResultIsFailure(status)) {
fprintf(stderr, "Unexpected failure parsing pipeline after registering the pass\n"); fprintf(stderr, "Unexpected failure parsing pipeline after registering the pass\n");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// CHECK: Round-trip: builtin.module(builtin.func(print-op-stats), builtin.func(print-op-stats)) // CHECK: Round-trip: builtin.module(func.func(print-op-stats),
// func.func(print-op-stats))
fprintf(stderr, "Round-trip: "); fprintf(stderr, "Round-trip: ");
mlirPrintPassPipeline(mlirPassManagerGetAsOpPassManager(pm), printToStderr, mlirPrintPassPipeline(mlirPassManagerGetAsOpPassManager(pm), printToStderr,
NULL); NULL);
fprintf(stderr, "\n"); fprintf(stderr, "\n");
mlirPassManagerDestroy(pm); mlirPassManagerDestroy(pm);
mlirContextDestroy(ctx); mlirContextDestroy(ctx);
} }
int main() { int main() {
testRunPassOnModule(); testRunPassOnModule();
testRunPassOnNestedModule(); testRunPassOnNestedModule();
testPrintPassPipeline(); testPrintPassPipeline();
testParsePassPipeline(); testParsePassPipeline();
return 0; return 0;
} }

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

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

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

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

mlir/test/Conversion/ComplexToStandard/convert-to-standard.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.func(convert-complex-to-standard)" | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="func.func(convert-complex-to-standard)" | FileCheck %s
// CHECK-LABEL: func @complex_abs // CHECK-LABEL: func @complex_abs
// CHECK-SAME: %[[ARG:.*]]: complex<f32> // CHECK-SAME: %[[ARG:.*]]: complex<f32>
func @complex_abs(%arg: complex<f32>) -> f32 { func @complex_abs(%arg: complex<f32>) -> f32 {
%abs = complex.abs %arg: complex<f32> %abs = complex.abs %arg: complex<f32>
return %abs : f32 return %abs : f32
} }
// CHECK: %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32> // CHECK: %[[REAL:.*]] = complex.re %[[ARG]] : complex<f32>
▲ Show 20 Lines • Show All 389 Lines • Show Last 20 Lines

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

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

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

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

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

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

mlir/test/Conversion/GPUToNVVM/gpu-to-nvvm.mlir

// RUN: mlir-opt %s -convert-gpu-to-nvvm -split-input-file | FileCheck %s // RUN: mlir-opt %s -convert-gpu-to-nvvm -split-input-file | FileCheck %s
// RUN: mlir-opt %s -convert-gpu-to-nvvm='index-bitwidth=32' -split-input-file | FileCheck --check-prefix=CHECK32 %s // RUN: mlir-opt %s -convert-gpu-to-nvvm='index-bitwidth=32' -split-input-file | FileCheck --check-prefix=CHECK32 %s
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_index_ops() // CHECK-LABEL: func @gpu_index_ops()
// CHECK32-LABEL: func @gpu_index_ops() // CHECK32-LABEL: func @gpu_index_ops()
builtin.func @gpu_index_ops() func.func @gpu_index_ops()
-> (index, index, index, index, index, index, -> (index, index, index, index, index, index,
index, index, index, index, index, index) { index, index, index, index, index, index) {
// CHECK32-NOT: = llvm.sext %{{.*}} : i32 to i64 // CHECK32-NOT: = llvm.sext %{{.*}} : i32 to i64
// CHECK: = nvvm.read.ptx.sreg.tid.x : i32 // CHECK: = nvvm.read.ptx.sreg.tid.x : i32
// CHECK: = llvm.sext %{{.*}} : i32 to i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%tIdX = gpu.thread_id x %tIdX = gpu.thread_id x
// CHECK: = nvvm.read.ptx.sreg.tid.y : i32 // CHECK: = nvvm.read.ptx.sreg.tid.y : i32
Show All 40 Linesgpu.module @test_module {
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_index_comp // CHECK-LABEL: func @gpu_index_comp
// CHECK32-LABEL: func @gpu_index_comp // CHECK32-LABEL: func @gpu_index_comp
builtin.func @gpu_index_comp(%idx : index) -> index { func.func @gpu_index_comp(%idx : index) -> index {
// CHECK: = llvm.add %{{.*}}, %{{.*}} : i64 // CHECK: = llvm.add %{{.*}}, %{{.*}} : i64
// CHECK32: = llvm.add %{{.*}}, %{{.*}} : i32 // CHECK32: = llvm.add %{{.*}}, %{{.*}} : i32
%0 = arith.addi %idx, %idx : index %0 = arith.addi %idx, %idx : index
// CHECK: llvm.return %{{.*}} : i64 // CHECK: llvm.return %{{.*}} : i64
// CHECK32: llvm.return %{{.*}} : i32 // CHECK32: llvm.return %{{.*}} : i32
func.return %0 : index func.return %0 : index
} }
} }
Show All 31 Lines gpu.func @gpu_all_reduce_region() {
gpu.return gpu.return
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_shuffle() // CHECK-LABEL: func @gpu_shuffle()
builtin.func @gpu_shuffle() -> (f32, f32, f32, f32) { func.func @gpu_shuffle() -> (f32, f32, f32, f32) {
// CHECK: %[[#VALUE:]] = llvm.mlir.constant(1.000000e+00 : f32) : f32 // CHECK: %[[#VALUE:]] = llvm.mlir.constant(1.000000e+00 : f32) : f32
%arg0 = arith.constant 1.0 : f32 %arg0 = arith.constant 1.0 : f32
// CHECK: %[[#OFFSET:]] = llvm.mlir.constant(4 : i32) : i32 // CHECK: %[[#OFFSET:]] = llvm.mlir.constant(4 : i32) : i32
%arg1 = arith.constant 4 : i32 %arg1 = arith.constant 4 : i32
// CHECK: %[[#WIDTH:]] = llvm.mlir.constant(23 : i32) : i32 // CHECK: %[[#WIDTH:]] = llvm.mlir.constant(23 : i32) : i32
%arg2 = arith.constant 23 : i32 %arg2 = arith.constant 23 : i32
// CHECK: %[[#ONE:]] = llvm.mlir.constant(1 : i32) : i32 // CHECK: %[[#ONE:]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[#MINUS_ONE:]] = llvm.mlir.constant(-1 : i32) : i32 // CHECK: %[[#MINUS_ONE:]] = llvm.mlir.constant(-1 : i32) : i32
Show All 22 Lines func.func @gpu_shuffle() -> (f32, f32, f32, f32) {
func.return %shfl, %shflu, %shfld, %shfli : f32, f32,f32, f32 func.return %shfl, %shflu, %shfld, %shfli : f32, f32,f32, f32
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_sync() // CHECK-LABEL: func @gpu_sync()
builtin.func @gpu_sync() { func.func @gpu_sync() {
// CHECK: nvvm.barrier0 // CHECK: nvvm.barrier0
gpu.barrier gpu.barrier
func.return func.return
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_fabsf(f32) -> f32 // CHECK: llvm.func @__nv_fabsf(f32) -> f32
// CHECK: llvm.func @__nv_fabs(f64) -> f64 // CHECK: llvm.func @__nv_fabs(f64) -> f64
// CHECK-LABEL: func @gpu_fabs // CHECK-LABEL: func @gpu_fabs
builtin.func @gpu_fabs(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_fabs(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.abs %arg_f32 : f32 %result32 = math.abs %arg_f32 : f32
// CHECK: llvm.call @__nv_fabsf(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_fabsf(%{{.*}}) : (f32) -> f32
%result64 = math.abs %arg_f64 : f64 %result64 = math.abs %arg_f64 : f64
// CHECK: llvm.call @__nv_fabs(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_fabs(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_ceilf(f32) -> f32 // CHECK: llvm.func @__nv_ceilf(f32) -> f32
// CHECK: llvm.func @__nv_ceil(f64) -> f64 // CHECK: llvm.func @__nv_ceil(f64) -> f64
// CHECK-LABEL: func @gpu_ceil // CHECK-LABEL: func @gpu_ceil
builtin.func @gpu_ceil(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_ceil(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.ceil %arg_f32 : f32 %result32 = math.ceil %arg_f32 : f32
// CHECK: llvm.call @__nv_ceilf(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_ceilf(%{{.*}}) : (f32) -> f32
%result64 = math.ceil %arg_f64 : f64 %result64 = math.ceil %arg_f64 : f64
// CHECK: llvm.call @__nv_ceil(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_ceil(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_floorf(f32) -> f32 // CHECK: llvm.func @__nv_floorf(f32) -> f32
// CHECK: llvm.func @__nv_floor(f64) -> f64 // CHECK: llvm.func @__nv_floor(f64) -> f64
// CHECK-LABEL: func @gpu_floor // CHECK-LABEL: func @gpu_floor
builtin.func @gpu_floor(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_floor(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.floor %arg_f32 : f32 %result32 = math.floor %arg_f32 : f32
// CHECK: llvm.call @__nv_floorf(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_floorf(%{{.*}}) : (f32) -> f32
%result64 = math.floor %arg_f64 : f64 %result64 = math.floor %arg_f64 : f64
// CHECK: llvm.call @__nv_floor(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_floor(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_cosf(f32) -> f32 // CHECK: llvm.func @__nv_cosf(f32) -> f32
// CHECK: llvm.func @__nv_cos(f64) -> f64 // CHECK: llvm.func @__nv_cos(f64) -> f64
// CHECK-LABEL: func @gpu_cos // CHECK-LABEL: func @gpu_cos
builtin.func @gpu_cos(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_cos(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.cos %arg_f32 : f32 %result32 = math.cos %arg_f32 : f32
// CHECK: llvm.call @__nv_cosf(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_cosf(%{{.*}}) : (f32) -> f32
%result64 = math.cos %arg_f64 : f64 %result64 = math.cos %arg_f64 : f64
// CHECK: llvm.call @__nv_cos(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_cos(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_expf(f32) -> f32 // CHECK: llvm.func @__nv_expf(f32) -> f32
// CHECK: llvm.func @__nv_exp(f64) -> f64 // CHECK: llvm.func @__nv_exp(f64) -> f64
// CHECK-LABEL: func @gpu_exp // CHECK-LABEL: func @gpu_exp
builtin.func @gpu_exp(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_exp(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.exp %arg_f32 : f32 %result32 = math.exp %arg_f32 : f32
// CHECK: llvm.call @__nv_expf(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_expf(%{{.*}}) : (f32) -> f32
%result64 = math.exp %arg_f64 : f64 %result64 = math.exp %arg_f64 : f64
// CHECK: llvm.call @__nv_exp(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_exp(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_exp2f(f32) -> f32 // CHECK: llvm.func @__nv_exp2f(f32) -> f32
// CHECK: llvm.func @__nv_exp2(f64) -> f64 // CHECK: llvm.func @__nv_exp2(f64) -> f64
// CHECK-LABEL: func @gpu_exp2 // CHECK-LABEL: func @gpu_exp2
builtin.func @gpu_exp2(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_exp2(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.exp2 %arg_f32 : f32 %result32 = math.exp2 %arg_f32 : f32
// CHECK: llvm.call @__nv_exp2f(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_exp2f(%{{.*}}) : (f32) -> f32
%result64 = math.exp2 %arg_f64 : f64 %result64 = math.exp2 %arg_f64 : f64
// CHECK: llvm.call @__nv_exp2(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_exp2(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_logf(f32) -> f32 // CHECK: llvm.func @__nv_logf(f32) -> f32
// CHECK: llvm.func @__nv_log(f64) -> f64 // CHECK: llvm.func @__nv_log(f64) -> f64
// CHECK-LABEL: func @gpu_log // CHECK-LABEL: func @gpu_log
builtin.func @gpu_log(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_log(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.log %arg_f32 : f32 %result32 = math.log %arg_f32 : f32
// CHECK: llvm.call @__nv_logf(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_logf(%{{.*}}) : (f32) -> f32
%result64 = math.log %arg_f64 : f64 %result64 = math.log %arg_f64 : f64
// CHECK: llvm.call @__nv_log(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_log(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_log10f(f32) -> f32 // CHECK: llvm.func @__nv_log10f(f32) -> f32
// CHECK: llvm.func @__nv_log10(f64) -> f64 // CHECK: llvm.func @__nv_log10(f64) -> f64
// CHECK-LABEL: func @gpu_log10 // CHECK-LABEL: func @gpu_log10
builtin.func @gpu_log10(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_log10(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.log10 %arg_f32 : f32 %result32 = math.log10 %arg_f32 : f32
// CHECK: llvm.call @__nv_log10f(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_log10f(%{{.*}}) : (f32) -> f32
%result64 = math.log10 %arg_f64 : f64 %result64 = math.log10 %arg_f64 : f64
// CHECK: llvm.call @__nv_log10(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_log10(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_log1pf(f32) -> f32 // CHECK: llvm.func @__nv_log1pf(f32) -> f32
// CHECK: llvm.func @__nv_log1p(f64) -> f64 // CHECK: llvm.func @__nv_log1p(f64) -> f64
// CHECK-LABEL: func @gpu_log1p // CHECK-LABEL: func @gpu_log1p
builtin.func @gpu_log1p(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_log1p(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.log1p %arg_f32 : f32 %result32 = math.log1p %arg_f32 : f32
// CHECK: llvm.call @__nv_log1pf(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_log1pf(%{{.*}}) : (f32) -> f32
%result64 = math.log1p %arg_f64 : f64 %result64 = math.log1p %arg_f64 : f64
// CHECK: llvm.call @__nv_log1p(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_log1p(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_log2f(f32) -> f32 // CHECK: llvm.func @__nv_log2f(f32) -> f32
// CHECK: llvm.func @__nv_log2(f64) -> f64 // CHECK: llvm.func @__nv_log2(f64) -> f64
// CHECK-LABEL: func @gpu_log2 // CHECK-LABEL: func @gpu_log2
builtin.func @gpu_log2(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_log2(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.log2 %arg_f32 : f32 %result32 = math.log2 %arg_f32 : f32
// CHECK: llvm.call @__nv_log2f(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_log2f(%{{.*}}) : (f32) -> f32
%result64 = math.log2 %arg_f64 : f64 %result64 = math.log2 %arg_f64 : f64
// CHECK: llvm.call @__nv_log2(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_log2(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_sinf(f32) -> f32 // CHECK: llvm.func @__nv_sinf(f32) -> f32
// CHECK: llvm.func @__nv_sin(f64) -> f64 // CHECK: llvm.func @__nv_sin(f64) -> f64
// CHECK-LABEL: func @gpu_sin // CHECK-LABEL: func @gpu_sin
builtin.func @gpu_sin(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_sin(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.sin %arg_f32 : f32 %result32 = math.sin %arg_f32 : f32
// CHECK: llvm.call @__nv_sinf(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_sinf(%{{.*}}) : (f32) -> f32
%result64 = math.sin %arg_f64 : f64 %result64 = math.sin %arg_f64 : f64
// CHECK: llvm.call @__nv_sin(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_sin(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_tanhf(f32) -> f32 // CHECK: llvm.func @__nv_tanhf(f32) -> f32
// CHECK: llvm.func @__nv_tanh(f64) -> f64 // CHECK: llvm.func @__nv_tanh(f64) -> f64
// CHECK-LABEL: func @gpu_tanh // CHECK-LABEL: func @gpu_tanh
builtin.func @gpu_tanh(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) { func.func @gpu_tanh(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
%result16 = math.tanh %arg_f16 : f16 %result16 = math.tanh %arg_f16 : f16
// CHECK: llvm.fpext %{{.*}} : f16 to f32 // CHECK: llvm.fpext %{{.*}} : f16 to f32
// CHECK-NEXT: llvm.call @__nv_tanhf(%{{.*}}) : (f32) -> f32 // CHECK-NEXT: llvm.call @__nv_tanhf(%{{.*}}) : (f32) -> f32
// CHECK-NEXT: llvm.fptrunc %{{.*}} : f32 to f16 // CHECK-NEXT: llvm.fptrunc %{{.*}} : f32 to f16
%result32 = math.tanh %arg_f32 : f32 %result32 = math.tanh %arg_f32 : f32
// CHECK: llvm.call @__nv_tanhf(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_tanhf(%{{.*}}) : (f32) -> f32
%result64 = math.tanh %arg_f64 : f64 %result64 = math.tanh %arg_f64 : f64
// CHECK: llvm.call @__nv_tanh(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_tanh(%{{.*}}) : (f64) -> f64
func.return %result16, %result32, %result64 : f16, f32, f64 func.return %result16, %result32, %result64 : f16, f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_rsqrtf(f32) -> f32 // CHECK: llvm.func @__nv_rsqrtf(f32) -> f32
// CHECK: llvm.func @__nv_rsqrt(f64) -> f64 // CHECK: llvm.func @__nv_rsqrt(f64) -> f64
// CHECK-LABEL: func @gpu_rsqrt // CHECK-LABEL: func @gpu_rsqrt
builtin.func @gpu_rsqrt(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) func.func @gpu_rsqrt(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64)
-> (f16, f32, f64) { -> (f16, f32, f64) {
%result16 = math.rsqrt %arg_f16 : f16 %result16 = math.rsqrt %arg_f16 : f16
// CHECK: llvm.fpext %{{.*}} : f16 to f32 // CHECK: llvm.fpext %{{.*}} : f16 to f32
// CHECK-NEXT: llvm.call @__nv_rsqrtf(%{{.*}}) : (f32) -> f32 // CHECK-NEXT: llvm.call @__nv_rsqrtf(%{{.*}}) : (f32) -> f32
// CHECK-NEXT: llvm.fptrunc %{{.*}} : f32 to f16 // CHECK-NEXT: llvm.fptrunc %{{.*}} : f32 to f16
%result32 = math.rsqrt %arg_f32 : f32 %result32 = math.rsqrt %arg_f32 : f32
// CHECK: llvm.call @__nv_rsqrtf(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_rsqrtf(%{{.*}}) : (f32) -> f32
%result64 = math.rsqrt %arg_f64 : f64 %result64 = math.rsqrt %arg_f64 : f64
// CHECK: llvm.call @__nv_rsqrt(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_rsqrt(%{{.*}}) : (f64) -> f64
func.return %result16, %result32, %result64 : f16, f32, f64 func.return %result16, %result32, %result64 : f16, f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_sqrtf(f32) -> f32 // CHECK: llvm.func @__nv_sqrtf(f32) -> f32
// CHECK: llvm.func @__nv_sqrt(f64) -> f64 // CHECK: llvm.func @__nv_sqrt(f64) -> f64
// CHECK-LABEL: func @gpu_sqrt // CHECK-LABEL: func @gpu_sqrt
builtin.func @gpu_sqrt(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) func.func @gpu_sqrt(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64)
-> (f16, f32, f64) { -> (f16, f32, f64) {
%result16 = math.sqrt %arg_f16 : f16 %result16 = math.sqrt %arg_f16 : f16
// CHECK: llvm.fpext %{{.*}} : f16 to f32 // CHECK: llvm.fpext %{{.*}} : f16 to f32
// CHECK-NEXT: llvm.call @__nv_sqrtf(%{{.*}}) : (f32) -> f32 // CHECK-NEXT: llvm.call @__nv_sqrtf(%{{.*}}) : (f32) -> f32
// CHECK-NEXT: llvm.fptrunc %{{.*}} : f32 to f16 // CHECK-NEXT: llvm.fptrunc %{{.*}} : f32 to f16
%result32 = math.sqrt %arg_f32 : f32 %result32 = math.sqrt %arg_f32 : f32
// CHECK: llvm.call @__nv_sqrtf(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_sqrtf(%{{.*}}) : (f32) -> f32
%result64 = math.sqrt %arg_f64 : f64 %result64 = math.sqrt %arg_f64 : f64
// CHECK: llvm.call @__nv_sqrt(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_sqrt(%{{.*}}) : (f64) -> f64
func.return %result16, %result32, %result64 : f16, f32, f64 func.return %result16, %result32, %result64 : f16, f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_atanf(f32) -> f32 // CHECK: llvm.func @__nv_atanf(f32) -> f32
// CHECK: llvm.func @__nv_atan(f64) -> f64 // CHECK: llvm.func @__nv_atan(f64) -> f64
// CHECK-LABEL: func @gpu_atan // CHECK-LABEL: func @gpu_atan
builtin.func @gpu_atan(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) func.func @gpu_atan(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64)
-> (f16, f32, f64) { -> (f16, f32, f64) {
%result16 = math.atan %arg_f16 : f16 %result16 = math.atan %arg_f16 : f16
// CHECK: llvm.fpext %{{.*}} : f16 to f32 // CHECK: llvm.fpext %{{.*}} : f16 to f32
// CHECK-NEXT: llvm.call @__nv_atanf(%{{.*}}) : (f32) -> f32 // CHECK-NEXT: llvm.call @__nv_atanf(%{{.*}}) : (f32) -> f32
// CHECK-NEXT: llvm.fptrunc %{{.*}} : f32 to f16 // CHECK-NEXT: llvm.fptrunc %{{.*}} : f32 to f16
%result32 = math.atan %arg_f32 : f32 %result32 = math.atan %arg_f32 : f32
// CHECK: llvm.call @__nv_atanf(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_atanf(%{{.*}}) : (f32) -> f32
%result64 = math.atan %arg_f64 : f64 %result64 = math.atan %arg_f64 : f64
// CHECK: llvm.call @__nv_atan(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_atan(%{{.*}}) : (f64) -> f64
func.return %result16, %result32, %result64 : f16, f32, f64 func.return %result16, %result32, %result64 : f16, f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_atan2f(f32, f32) -> f32 // CHECK: llvm.func @__nv_atan2f(f32, f32) -> f32
// CHECK: llvm.func @__nv_atan2(f64, f64) -> f64 // CHECK: llvm.func @__nv_atan2(f64, f64) -> f64
// CHECK-LABEL: func @gpu_atan2 // CHECK-LABEL: func @gpu_atan2
builtin.func @gpu_atan2(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) func.func @gpu_atan2(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64)
-> (f16, f32, f64) { -> (f16, f32, f64) {
%result16 = math.atan2 %arg_f16, %arg_f16 : f16 %result16 = math.atan2 %arg_f16, %arg_f16 : f16
// CHECK: llvm.fpext %{{.*}} : f16 to f32 // CHECK: llvm.fpext %{{.*}} : f16 to f32
// CHECK: llvm.fpext %{{.*}} : f16 to f32 // CHECK: llvm.fpext %{{.*}} : f16 to f32
// CHECK-NEXT: llvm.call @__nv_atan2f(%{{.*}}) : (f32, f32) -> f32 // CHECK-NEXT: llvm.call @__nv_atan2f(%{{.*}}) : (f32, f32) -> f32
// CHECK-NEXT: llvm.fptrunc %{{.*}} : f32 to f16 // CHECK-NEXT: llvm.fptrunc %{{.*}} : f32 to f16
%result32 = math.atan2 %arg_f32, %arg_f32 : f32 %result32 = math.atan2 %arg_f32, %arg_f32 : f32
// CHECK: llvm.call @__nv_atan2f(%{{.*}}) : (f32, f32) -> f32 // CHECK: llvm.call @__nv_atan2f(%{{.*}}) : (f32, f32) -> f32
%result64 = math.atan2 %arg_f64, %arg_f64 : f64 %result64 = math.atan2 %arg_f64, %arg_f64 : f64
// CHECK: llvm.call @__nv_atan2(%{{.*}}) : (f64, f64) -> f64 // CHECK: llvm.call @__nv_atan2(%{{.*}}) : (f64, f64) -> f64
func.return %result16, %result32, %result64 : f16, f32, f64 func.return %result16, %result32, %result64 : f16, f32, f64
} }
} }
// ----- // -----
// Test that we handled properly operation with SymbolTable other than module op // Test that we handled properly operation with SymbolTable other than module op
gpu.module @test_module { gpu.module @test_module {
"test.symbol_scope"() ({ "test.symbol_scope"() ({
// CHECK: test.symbol_scope // CHECK: test.symbol_scope
// CHECK: llvm.func @__nv_expf(f32) -> f32 // CHECK: llvm.func @__nv_expf(f32) -> f32
// CHECK: llvm.func @__nv_exp(f64) -> f64 // CHECK: llvm.func @__nv_exp(f64) -> f64
// CHECK-LABEL: func @gpu_exp // CHECK-LABEL: func @gpu_exp
builtin.func @gpu_exp(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_exp(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.exp %arg_f32 : f32 %result32 = math.exp %arg_f32 : f32
// CHECK: llvm.call @__nv_expf(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_expf(%{{.*}}) : (f32) -> f32
%result64 = math.exp %arg_f64 : f64 %result64 = math.exp %arg_f64 : f64
// CHECK: llvm.call @__nv_exp(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_exp(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
"test.finish" () : () -> () "test.finish" () : () -> ()
}) : () -> () }) : () -> ()
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_expm1f(f32) -> f32 // CHECK: llvm.func @__nv_expm1f(f32) -> f32
// CHECK: llvm.func @__nv_expm1(f64) -> f64 // CHECK: llvm.func @__nv_expm1(f64) -> f64
// CHECK-LABEL: func @gpu_expm1 // CHECK-LABEL: func @gpu_expm1
builtin.func @gpu_expm1(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_expm1(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.expm1 %arg_f32 : f32 %result32 = math.expm1 %arg_f32 : f32
// CHECK: llvm.call @__nv_expm1f(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__nv_expm1f(%{{.*}}) : (f32) -> f32
%result64 = math.expm1 %arg_f64 : f64 %result64 = math.expm1 %arg_f64 : f64
// CHECK: llvm.call @__nv_expm1(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__nv_expm1(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__nv_powf(f32, f32) -> f32 // CHECK: llvm.func @__nv_powf(f32, f32) -> f32
// CHECK: llvm.func @__nv_pow(f64, f64) -> f64 // CHECK: llvm.func @__nv_pow(f64, f64) -> f64
// CHECK-LABEL: func @gpu_pow // CHECK-LABEL: func @gpu_pow
builtin.func @gpu_pow(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_pow(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.powf %arg_f32, %arg_f32 : f32 %result32 = math.powf %arg_f32, %arg_f32 : f32
// CHECK: llvm.call @__nv_powf(%{{.*}}, %{{.*}}) : (f32, f32) -> f32 // CHECK: llvm.call @__nv_powf(%{{.*}}, %{{.*}}) : (f32, f32) -> f32
%result64 = math.powf %arg_f64, %arg_f64 : f64 %result64 = math.powf %arg_f64, %arg_f64 : f64
// CHECK: llvm.call @__nv_pow(%{{.*}}, %{{.*}}) : (f64, f64) -> f64 // CHECK: llvm.call @__nv_pow(%{{.*}}, %{{.*}}) : (f64, f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

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

// RUN: mlir-opt --convert-gpu-to-nvvm --split-input-file %s | FileCheck %s // RUN: mlir-opt --convert-gpu-to-nvvm --split-input-file %s | FileCheck %s
// RUN: mlir-opt --convert-gpu-to-nvvm="index-bitwidth=32" --split-input-file %s | FileCheck --check-prefix=CHECK32 %s // RUN: mlir-opt --convert-gpu-to-nvvm="index-bitwidth=32" --split-input-file %s | FileCheck --check-prefix=CHECK32 %s
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_wmma_load_op() -> // CHECK-LABEL: func @gpu_wmma_load_op() ->
// CHECK-SAME: !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> { // CHECK-SAME: !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> {
// CHECK32-LABEL: func @gpu_wmma_load_op() -> // CHECK32-LABEL: func @gpu_wmma_load_op() ->
builtin.func @gpu_wmma_load_op() -> (!gpu.mma_matrix<16x16xf16, "AOp">) { func.func @gpu_wmma_load_op() -> (!gpu.mma_matrix<16x16xf16, "AOp">) {
%wg = memref.alloca() {alignment = 32} : memref<32x32xf16, 3> %wg = memref.alloca() {alignment = 32} : memref<32x32xf16, 3>
%i = arith.constant 16 : index %i = arith.constant 16 : index
%j = arith.constant 16 : index %j = arith.constant 16 : index
%0 = gpu.subgroup_mma_load_matrix %wg[%i, %j] {leadDimension = 32 : index} : memref<32x32xf16, 3> -> !gpu.mma_matrix<16x16xf16, "AOp"> %0 = gpu.subgroup_mma_load_matrix %wg[%i, %j] {leadDimension = 32 : index} : memref<32x32xf16, 3> -> !gpu.mma_matrix<16x16xf16, "AOp">
// CHECK: %[[INX:.*]] = llvm.mlir.constant(16 : index) : i64 // CHECK: %[[INX:.*]] = llvm.mlir.constant(16 : index) : i64
// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[{{.*}}, {{.*}}] // CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[{{.*}}, {{.*}}]
// CHECK: %[[BASE:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<f16, 3>, ptr<f16, 3>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[BASE:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<f16, 3>, ptr<f16, 3>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[LDM:.*]] = llvm.mlir.constant(32 : index) : i64 // CHECK: %[[LDM:.*]] = llvm.mlir.constant(32 : index) : i64
Show All 23 Lines
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_wmma_store_op // CHECK-LABEL: func @gpu_wmma_store_op
// CHECK-SAME: (%[[D:.*]]: !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>) { // CHECK-SAME: (%[[D:.*]]: !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>) {
// CHECK32-LABEL: func @gpu_wmma_store_op // CHECK32-LABEL: func @gpu_wmma_store_op
// CHECK32-SAME: (%[[D:.*]]: !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>) { // CHECK32-SAME: (%[[D:.*]]: !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>) {
builtin.func @gpu_wmma_store_op(%arg0 : !gpu.mma_matrix<16x16xf16, "COp">) -> () { func.func @gpu_wmma_store_op(%arg0 : !gpu.mma_matrix<16x16xf16, "COp">) -> () {
%sg = memref.alloca(){alignment = 32} : memref<32x32xf16, 3> %sg = memref.alloca(){alignment = 32} : memref<32x32xf16, 3>
%i = arith.constant 16 : index %i = arith.constant 16 : index
%j = arith.constant 16 : index %j = arith.constant 16 : index
gpu.subgroup_mma_store_matrix %arg0, %sg[%i,%j] {leadDimension= 32 : index} : !gpu.mma_matrix<16x16xf16, "COp">, memref<32x32xf16, 3> gpu.subgroup_mma_store_matrix %arg0, %sg[%i,%j] {leadDimension= 32 : index} : !gpu.mma_matrix<16x16xf16, "COp">, memref<32x32xf16, 3>
// CHECK: %[[INX:.*]] = llvm.mlir.constant(16 : index) : i64 // CHECK: %[[INX:.*]] = llvm.mlir.constant(16 : index) : i64
// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[{{.*}}, {{.*}}] // CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[{{.*}}, {{.*}}]
// CHECK: %[[EL1:.*]] = llvm.extractvalue %[[D]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[EL1:.*]] = llvm.extractvalue %[[D]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[EL2:.*]] = llvm.extractvalue %[[D]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[EL2:.*]] = llvm.extractvalue %[[D]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
Show All 29 Lines
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_wmma_mma_op // CHECK-LABEL: func @gpu_wmma_mma_op
// CHECK-SAME: (%[[A:.*]]: !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>, %[[B:.*]]: !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>, %[[C:.*]]: !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>) // CHECK-SAME: (%[[A:.*]]: !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>, %[[B:.*]]: !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>, %[[C:.*]]: !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>)
builtin.func @gpu_wmma_mma_op(%A : !gpu.mma_matrix<16x16xf16, "AOp">, %B : !gpu.mma_matrix<16x16xf16, "BOp">, %C : !gpu.mma_matrix<16x16xf16, "COp">) -> (!gpu.mma_matrix<16x16xf16, "COp">) { func.func @gpu_wmma_mma_op(%A : !gpu.mma_matrix<16x16xf16, "AOp">, %B : !gpu.mma_matrix<16x16xf16, "BOp">, %C : !gpu.mma_matrix<16x16xf16, "COp">) -> (!gpu.mma_matrix<16x16xf16, "COp">) {
%D = gpu.subgroup_mma_compute %A, %B, %C : !gpu.mma_matrix<16x16xf16, "AOp">, !gpu.mma_matrix<16x16xf16, "BOp"> -> !gpu.mma_matrix<16x16xf16, "COp"> %D = gpu.subgroup_mma_compute %A, %B, %C : !gpu.mma_matrix<16x16xf16, "AOp">, !gpu.mma_matrix<16x16xf16, "BOp"> -> !gpu.mma_matrix<16x16xf16, "COp">
// CHECK: %[[A1:.*]] = llvm.extractvalue %[[A]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[A1:.*]] = llvm.extractvalue %[[A]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[A2:.*]] = llvm.extractvalue %[[A]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[A2:.*]] = llvm.extractvalue %[[A]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[A3:.*]] = llvm.extractvalue %[[A]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[A3:.*]] = llvm.extractvalue %[[A]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[A4:.*]] = llvm.extractvalue %[[A]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[A4:.*]] = llvm.extractvalue %[[A]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[A5:.*]] = llvm.extractvalue %[[A]][4 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[A5:.*]] = llvm.extractvalue %[[A]][4 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[A6:.*]] = llvm.extractvalue %[[A]][5 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[A6:.*]] = llvm.extractvalue %[[A]][5 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[A7:.*]] = llvm.extractvalue %[[A]][6 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[A7:.*]] = llvm.extractvalue %[[A]][6 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
// CHECK: llvm.br ^bb1(%{{.*}}, %[[ACC_MUL]] : i64, !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>) // CHECK: llvm.br ^bb1(%{{.*}}, %[[ACC_MUL]] : i64, !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>)
// CHECK: ^bb3: // pred: ^bb1 // CHECK: ^bb3: // pred: ^bb1
// CHECK: %[[E0:.+]] = llvm.extractvalue %[[ACC]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[E0:.+]] = llvm.extractvalue %[[ACC]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[E1:.+]] = llvm.extractvalue %[[ACC]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[E1:.+]] = llvm.extractvalue %[[ACC]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[E2:.+]] = llvm.extractvalue %[[ACC]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[E2:.+]] = llvm.extractvalue %[[ACC]][2 : 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: %[[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>) { func.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">
cf.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
cf.cond_br %3, ^bb2, ^bb3 cf.cond_br %3, ^bb2, ^bb3
Show All 22 Lines
// CHECK: %[[C1:.+]] = llvm.mlir.constant(1 : i32) : i32 // CHECK: %[[C1:.+]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[V2:.+]] = llvm.insertelement %[[CST]], %[[V1]][%[[C1]] : i32] : vector<2xf16> // CHECK: %[[V2:.+]] = llvm.insertelement %[[CST]], %[[V1]][%[[C1]] : i32] : vector<2xf16>
// CHECK: %[[M0:.+]] = llvm.mlir.undef : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[M0:.+]] = llvm.mlir.undef : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[M1:.+]] = llvm.insertvalue %[[V2]], %[[M0]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[M1:.+]] = llvm.insertvalue %[[V2]], %[[M0]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[M2:.+]] = llvm.insertvalue %[[V2]], %[[M1]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[M2:.+]] = llvm.insertvalue %[[V2]], %[[M1]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[M3:.+]] = llvm.insertvalue %[[V2]], %[[M2]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[M3:.+]] = llvm.insertvalue %[[V2]], %[[M2]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[M4:.+]] = llvm.insertvalue %[[V2]], %[[M3]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[M4:.+]] = llvm.insertvalue %[[V2]], %[[M3]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: llvm.return %[[M4]] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: llvm.return %[[M4]] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
builtin.func @gpu_wmma_constant_op() ->(!gpu.mma_matrix<16x16xf16, "COp">) { func.func @gpu_wmma_constant_op() ->(!gpu.mma_matrix<16x16xf16, "COp">) {
%cst = arith.constant 1.0 : f16 %cst = arith.constant 1.0 : f16
%C = gpu.subgroup_mma_constant_matrix %cst : !gpu.mma_matrix<16x16xf16, "COp"> %C = gpu.subgroup_mma_constant_matrix %cst : !gpu.mma_matrix<16x16xf16, "COp">
return %C : !gpu.mma_matrix<16x16xf16, "COp"> return %C : !gpu.mma_matrix<16x16xf16, "COp">
} }
} }
// ----- // -----
Show All 13 Lines
// CHECK: %[[B2:.*]] = llvm.extractvalue %{{.*}}[2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[B2:.*]] = llvm.extractvalue %{{.*}}[2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[C2:.*]] = llvm.fadd %[[A2]], %[[B2]] : vector<2xf16> // CHECK: %[[C2:.*]] = llvm.fadd %[[A2]], %[[B2]] : vector<2xf16>
// CHECK: %[[M3:.*]] = llvm.insertvalue %[[C2]], %[[M2]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[M3:.*]] = llvm.insertvalue %[[C2]], %[[M2]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[A3:.*]] = llvm.extractvalue %{{.*}}[3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[A3:.*]] = llvm.extractvalue %{{.*}}[3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[B3:.*]] = llvm.extractvalue %{{.*}}[3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[B3:.*]] = llvm.extractvalue %{{.*}}[3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: %[[C3:.*]] = llvm.fadd %[[A3]], %[[B3]] : vector<2xf16> // CHECK: %[[C3:.*]] = llvm.fadd %[[A3]], %[[B3]] : vector<2xf16>
// CHECK: %[[M4:.*]] = llvm.insertvalue %[[C3]], %[[M3]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[M4:.*]] = llvm.insertvalue %[[C3]], %[[M3]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
// CHECK: llvm.return %[[M4]] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: llvm.return %[[M4]] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>
builtin.func @gpu_wmma_elementwise(%A : !gpu.mma_matrix<16x16xf16, "COp">, %B : !gpu.mma_matrix<16x16xf16, "COp">) ->(!gpu.mma_matrix<16x16xf16, "COp">) { func.func @gpu_wmma_elementwise(%A : !gpu.mma_matrix<16x16xf16, "COp">, %B : !gpu.mma_matrix<16x16xf16, "COp">) ->(!gpu.mma_matrix<16x16xf16, "COp">) {
%C = gpu.subgroup_mma_elementwise addf %A, %B : (!gpu.mma_matrix<16x16xf16, "COp">, !gpu.mma_matrix<16x16xf16, "COp">) -> !gpu.mma_matrix<16x16xf16, "COp"> %C = gpu.subgroup_mma_elementwise addf %A, %B : (!gpu.mma_matrix<16x16xf16, "COp">, !gpu.mma_matrix<16x16xf16, "COp">) -> !gpu.mma_matrix<16x16xf16, "COp">
return %C : !gpu.mma_matrix<16x16xf16, "COp"> return %C : !gpu.mma_matrix<16x16xf16, "COp">
} }
} }

mlir/test/Conversion/GPUToROCDL/gpu-to-rocdl.mlir

// RUN: mlir-opt %s -convert-gpu-to-rocdl -split-input-file | FileCheck %s // RUN: mlir-opt %s -convert-gpu-to-rocdl -split-input-file | FileCheck %s
// RUN: mlir-opt %s -convert-gpu-to-rocdl='index-bitwidth=32' -split-input-file | FileCheck --check-prefix=CHECK32 %s // RUN: mlir-opt %s -convert-gpu-to-rocdl='index-bitwidth=32' -split-input-file | FileCheck --check-prefix=CHECK32 %s
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_index_ops() // CHECK-LABEL: func @gpu_index_ops()
// CHECK32-LABEL: func @gpu_index_ops() // CHECK32-LABEL: func @gpu_index_ops()
builtin.func @gpu_index_ops() func.func @gpu_index_ops()
-> (index, index, index, index, index, index, -> (index, index, index, index, index, index,
index, index, index, index, index, index) { index, index, index, index, index, index) {
// CHECK32-NOT: = llvm.sext %{{.*}} : i32 to i64 // CHECK32-NOT: = llvm.sext %{{.*}} : i32 to i64
// CHECK: rocdl.workitem.id.x : i32 // CHECK: rocdl.workitem.id.x : i32
// CHECK: = llvm.sext %{{.*}} : i32 to i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%tIdX = gpu.thread_id x %tIdX = gpu.thread_id x
// CHECK: rocdl.workitem.id.y : i32 // CHECK: rocdl.workitem.id.y : i32
Show All 40 Linesgpu.module @test_module {
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_index_comp // CHECK-LABEL: func @gpu_index_comp
// CHECK32-LABEL: func @gpu_index_comp // CHECK32-LABEL: func @gpu_index_comp
builtin.func @gpu_index_comp(%idx : index) -> index { func.func @gpu_index_comp(%idx : index) -> index {
// CHECK: = llvm.add %{{.*}}, %{{.*}} : i64 // CHECK: = llvm.add %{{.*}}, %{{.*}} : i64
// CHECK32: = llvm.add %{{.*}}, %{{.*}} : i32 // CHECK32: = llvm.add %{{.*}}, %{{.*}} : i32
%0 = arith.addi %idx, %idx : index %0 = arith.addi %idx, %idx : index
// CHECK: llvm.return %{{.*}} : i64 // CHECK: llvm.return %{{.*}} : i64
// CHECK32: llvm.return %{{.*}} : i32 // CHECK32: llvm.return %{{.*}} : i32
func.return %0 : index func.return %0 : index
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_sync() // CHECK-LABEL: func @gpu_sync()
builtin.func @gpu_sync() { func.func @gpu_sync() {
// CHECK: rocdl.barrier // CHECK: rocdl.barrier
gpu.barrier gpu.barrier
func.return func.return
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_fabs_f32(f32) -> f32 // CHECK: llvm.func @__ocml_fabs_f32(f32) -> f32
// CHECK: llvm.func @__ocml_fabs_f64(f64) -> f64 // CHECK: llvm.func @__ocml_fabs_f64(f64) -> f64
// CHECK-LABEL: func @gpu_fabs // CHECK-LABEL: func @gpu_fabs
builtin.func @gpu_fabs(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_fabs(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.abs %arg_f32 : f32 %result32 = math.abs %arg_f32 : f32
// CHECK: llvm.call @__ocml_fabs_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_fabs_f32(%{{.*}}) : (f32) -> f32
%result64 = math.abs %arg_f64 : f64 %result64 = math.abs %arg_f64 : f64
// CHECK: llvm.call @__ocml_fabs_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_fabs_f64(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_ceil_f32(f32) -> f32 // CHECK: llvm.func @__ocml_ceil_f32(f32) -> f32
// CHECK: llvm.func @__ocml_ceil_f64(f64) -> f64 // CHECK: llvm.func @__ocml_ceil_f64(f64) -> f64
// CHECK-LABEL: func @gpu_ceil // CHECK-LABEL: func @gpu_ceil
builtin.func @gpu_ceil(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_ceil(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.ceil %arg_f32 : f32 %result32 = math.ceil %arg_f32 : f32
// CHECK: llvm.call @__ocml_ceil_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_ceil_f32(%{{.*}}) : (f32) -> f32
%result64 = math.ceil %arg_f64 : f64 %result64 = math.ceil %arg_f64 : f64
// CHECK: llvm.call @__ocml_ceil_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_ceil_f64(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_floor_f32(f32) -> f32 // CHECK: llvm.func @__ocml_floor_f32(f32) -> f32
// CHECK: llvm.func @__ocml_floor_f64(f64) -> f64 // CHECK: llvm.func @__ocml_floor_f64(f64) -> f64
// CHECK-LABEL: func @gpu_floor // CHECK-LABEL: func @gpu_floor
builtin.func @gpu_floor(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_floor(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.floor %arg_f32 : f32 %result32 = math.floor %arg_f32 : f32
// CHECK: llvm.call @__ocml_floor_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_floor_f32(%{{.*}}) : (f32) -> f32
%result64 = math.floor %arg_f64 : f64 %result64 = math.floor %arg_f64 : f64
// CHECK: llvm.call @__ocml_floor_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_floor_f64(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_cos_f32(f32) -> f32 // CHECK: llvm.func @__ocml_cos_f32(f32) -> f32
// CHECK: llvm.func @__ocml_cos_f64(f64) -> f64 // CHECK: llvm.func @__ocml_cos_f64(f64) -> f64
// CHECK-LABEL: func @gpu_cos // CHECK-LABEL: func @gpu_cos
builtin.func @gpu_cos(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_cos(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.cos %arg_f32 : f32 %result32 = math.cos %arg_f32 : f32
// CHECK: llvm.call @__ocml_cos_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_cos_f32(%{{.*}}) : (f32) -> f32
%result64 = math.cos %arg_f64 : f64 %result64 = math.cos %arg_f64 : f64
// CHECK: llvm.call @__ocml_cos_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_cos_f64(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_exp_f32(f32) -> f32 // CHECK: llvm.func @__ocml_exp_f32(f32) -> f32
// CHECK: llvm.func @__ocml_exp_f64(f64) -> f64 // CHECK: llvm.func @__ocml_exp_f64(f64) -> f64
// CHECK-LABEL: func @gpu_exp // CHECK-LABEL: func @gpu_exp
builtin.func @gpu_exp(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_exp(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%exp_f32 = math.exp %arg_f32 : f32 %exp_f32 = math.exp %arg_f32 : f32
// CHECK: llvm.call @__ocml_exp_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_exp_f32(%{{.*}}) : (f32) -> f32
%result32 = math.exp %exp_f32 : f32 %result32 = math.exp %exp_f32 : f32
// CHECK: llvm.call @__ocml_exp_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_exp_f32(%{{.*}}) : (f32) -> f32
%result64 = math.exp %arg_f64 : f64 %result64 = math.exp %arg_f64 : f64
// CHECK: llvm.call @__ocml_exp_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_exp_f64(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_exp2_f32(f32) -> f32 // CHECK: llvm.func @__ocml_exp2_f32(f32) -> f32
// CHECK: llvm.func @__ocml_exp2_f64(f64) -> f64 // CHECK: llvm.func @__ocml_exp2_f64(f64) -> f64
// CHECK-LABEL: func @gpu_exp2 // CHECK-LABEL: func @gpu_exp2
builtin.func @gpu_exp2(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_exp2(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%exp2_f32 = math.exp2 %arg_f32 : f32 %exp2_f32 = math.exp2 %arg_f32 : f32
// CHECK: llvm.call @__ocml_exp2_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_exp2_f32(%{{.*}}) : (f32) -> f32
%result32 = math.exp2 %exp2_f32 : f32 %result32 = math.exp2 %exp2_f32 : f32
// CHECK: llvm.call @__ocml_exp2_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_exp2_f32(%{{.*}}) : (f32) -> f32
%result64 = math.exp2 %arg_f64 : f64 %result64 = math.exp2 %arg_f64 : f64
// CHECK: llvm.call @__ocml_exp2_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_exp2_f64(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
// Test that we handled properly operation with SymbolTable other than module op // Test that we handled properly operation with SymbolTable other than module op
gpu.module @test_module { gpu.module @test_module {
"test.symbol_scope"() ({ "test.symbol_scope"() ({
// CHECK: test.symbol_scope // CHECK: test.symbol_scope
// CHECK: llvm.func @__ocml_exp_f32(f32) -> f32 // CHECK: llvm.func @__ocml_exp_f32(f32) -> f32
// CHECK: llvm.func @__ocml_exp_f64(f64) -> f64 // CHECK: llvm.func @__ocml_exp_f64(f64) -> f64
// CHECK-LABEL: func @gpu_exp // CHECK-LABEL: func @gpu_exp
builtin.func @gpu_exp(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_exp(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%exp_f32 = math.exp %arg_f32 : f32 %exp_f32 = math.exp %arg_f32 : f32
// CHECK: llvm.call @__ocml_exp_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_exp_f32(%{{.*}}) : (f32) -> f32
%result32 = math.exp %exp_f32 : f32 %result32 = math.exp %exp_f32 : f32
// CHECK: llvm.call @__ocml_exp_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_exp_f32(%{{.*}}) : (f32) -> f32
%result64 = math.exp %arg_f64 : f64 %result64 = math.exp %arg_f64 : f64
// CHECK: llvm.call @__ocml_exp_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_exp_f64(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
"test.finish" () : () -> () "test.finish" () : () -> ()
}) : () -> () }) : () -> ()
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_expm1_f32(f32) -> f32 // CHECK: llvm.func @__ocml_expm1_f32(f32) -> f32
// CHECK: llvm.func @__ocml_expm1_f64(f64) -> f64 // CHECK: llvm.func @__ocml_expm1_f64(f64) -> f64
// CHECK-LABEL: func @gpu_expm1 // CHECK-LABEL: func @gpu_expm1
builtin.func @gpu_expm1(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_expm1(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%expm1_f32 = math.expm1 %arg_f32 : f32 %expm1_f32 = math.expm1 %arg_f32 : f32
// CHECK: llvm.call @__ocml_expm1_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_expm1_f32(%{{.*}}) : (f32) -> f32
%result32 = math.expm1 %expm1_f32 : f32 %result32 = math.expm1 %expm1_f32 : f32
// CHECK: llvm.call @__ocml_expm1_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_expm1_f32(%{{.*}}) : (f32) -> f32
%result64 = math.expm1 %arg_f64 : f64 %result64 = math.expm1 %arg_f64 : f64
// CHECK: llvm.call @__ocml_expm1_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_expm1_f64(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_log_f32(f32) -> f32 // CHECK: llvm.func @__ocml_log_f32(f32) -> f32
// CHECK: llvm.func @__ocml_log_f64(f64) -> f64 // CHECK: llvm.func @__ocml_log_f64(f64) -> f64
// CHECK-LABEL: func @gpu_log // CHECK-LABEL: func @gpu_log
builtin.func @gpu_log(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_log(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.log %arg_f32 : f32 %result32 = math.log %arg_f32 : f32
// CHECK: llvm.call @__ocml_log_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_log_f32(%{{.*}}) : (f32) -> f32
%result64 = math.log %arg_f64 : f64 %result64 = math.log %arg_f64 : f64
// CHECK: llvm.call @__ocml_log_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_log_f64(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_log1p_f32(f32) -> f32 // CHECK: llvm.func @__ocml_log1p_f32(f32) -> f32
// CHECK: llvm.func @__ocml_log1p_f64(f64) -> f64 // CHECK: llvm.func @__ocml_log1p_f64(f64) -> f64
// CHECK-LABEL: func @gpu_log1p // CHECK-LABEL: func @gpu_log1p
builtin.func @gpu_log1p(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_log1p(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.log1p %arg_f32 : f32 %result32 = math.log1p %arg_f32 : f32
// CHECK: llvm.call @__ocml_log1p_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_log1p_f32(%{{.*}}) : (f32) -> f32
%result64 = math.log1p %arg_f64 : f64 %result64 = math.log1p %arg_f64 : f64
// CHECK: llvm.call @__ocml_log1p_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_log1p_f64(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_log10_f32(f32) -> f32 // CHECK: llvm.func @__ocml_log10_f32(f32) -> f32
// CHECK: llvm.func @__ocml_log10_f64(f64) -> f64 // CHECK: llvm.func @__ocml_log10_f64(f64) -> f64
// CHECK-LABEL: func @gpu_log10 // CHECK-LABEL: func @gpu_log10
builtin.func @gpu_log10(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_log10(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.log10 %arg_f32 : f32 %result32 = math.log10 %arg_f32 : f32
// CHECK: llvm.call @__ocml_log10_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_log10_f32(%{{.*}}) : (f32) -> f32
%result64 = math.log10 %arg_f64 : f64 %result64 = math.log10 %arg_f64 : f64
// CHECK: llvm.call @__ocml_log10_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_log10_f64(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_log2_f32(f32) -> f32 // CHECK: llvm.func @__ocml_log2_f32(f32) -> f32
// CHECK: llvm.func @__ocml_log2_f64(f64) -> f64 // CHECK: llvm.func @__ocml_log2_f64(f64) -> f64
// CHECK-LABEL: func @gpu_log2 // CHECK-LABEL: func @gpu_log2
builtin.func @gpu_log2(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_log2(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.log2 %arg_f32 : f32 %result32 = math.log2 %arg_f32 : f32
// CHECK: llvm.call @__ocml_log2_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_log2_f32(%{{.*}}) : (f32) -> f32
%result64 = math.log2 %arg_f64 : f64 %result64 = math.log2 %arg_f64 : f64
// CHECK: llvm.call @__ocml_log2_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_log2_f64(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_rsqrt_f32(f32) -> f32 // CHECK: llvm.func @__ocml_rsqrt_f32(f32) -> f32
// CHECK: llvm.func @__ocml_rsqrt_f64(f64) -> f64 // CHECK: llvm.func @__ocml_rsqrt_f64(f64) -> f64
// CHECK-LABEL: func @gpu_rsqrt // CHECK-LABEL: func @gpu_rsqrt
builtin.func @gpu_rsqrt(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) func.func @gpu_rsqrt(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64)
-> (f16, f32, f64) { -> (f16, f32, f64) {
%result16 = math.rsqrt %arg_f16 : f16 %result16 = math.rsqrt %arg_f16 : f16
// CHECK: llvm.fpext %{{.*}} : f16 to f32 // CHECK: llvm.fpext %{{.*}} : f16 to f32
// CHECK-NEXT: llvm.call @__ocml_rsqrt_f32(%{{.*}}) : (f32) -> f32 // CHECK-NEXT: llvm.call @__ocml_rsqrt_f32(%{{.*}}) : (f32) -> f32
// CHECK-NEXT: llvm.fptrunc %{{.*}} : f32 to f16 // CHECK-NEXT: llvm.fptrunc %{{.*}} : f32 to f16
%result32 = math.rsqrt %arg_f32 : f32 %result32 = math.rsqrt %arg_f32 : f32
// CHECK: llvm.call @__ocml_rsqrt_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_rsqrt_f32(%{{.*}}) : (f32) -> f32
%result64 = math.rsqrt %arg_f64 : f64 %result64 = math.rsqrt %arg_f64 : f64
// CHECK: llvm.call @__ocml_rsqrt_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_rsqrt_f64(%{{.*}}) : (f64) -> f64
func.return %result16, %result32, %result64 : f16, f32, f64 func.return %result16, %result32, %result64 : f16, f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_sqrt_f32(f32) -> f32 // CHECK: llvm.func @__ocml_sqrt_f32(f32) -> f32
// CHECK: llvm.func @__ocml_sqrt_f64(f64) -> f64 // CHECK: llvm.func @__ocml_sqrt_f64(f64) -> f64
// CHECK-LABEL: func @gpu_sqrt // CHECK-LABEL: func @gpu_sqrt
builtin.func @gpu_sqrt(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) func.func @gpu_sqrt(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64)
-> (f16, f32, f64) { -> (f16, f32, f64) {
%result16 = math.sqrt %arg_f16 : f16 %result16 = math.sqrt %arg_f16 : f16
// CHECK: llvm.fpext %{{.*}} : f16 to f32 // CHECK: llvm.fpext %{{.*}} : f16 to f32
// CHECK-NEXT: llvm.call @__ocml_sqrt_f32(%{{.*}}) : (f32) -> f32 // CHECK-NEXT: llvm.call @__ocml_sqrt_f32(%{{.*}}) : (f32) -> f32
// CHECK-NEXT: llvm.fptrunc %{{.*}} : f32 to f16 // CHECK-NEXT: llvm.fptrunc %{{.*}} : f32 to f16
%result32 = math.sqrt %arg_f32 : f32 %result32 = math.sqrt %arg_f32 : f32
// CHECK: llvm.call @__ocml_sqrt_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_sqrt_f32(%{{.*}}) : (f32) -> f32
%result64 = math.sqrt %arg_f64 : f64 %result64 = math.sqrt %arg_f64 : f64
// CHECK: llvm.call @__ocml_sqrt_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_sqrt_f64(%{{.*}}) : (f64) -> f64
func.return %result16, %result32, %result64 : f16, f32, f64 func.return %result16, %result32, %result64 : f16, f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_tanh_f32(f32) -> f32 // CHECK: llvm.func @__ocml_tanh_f32(f32) -> f32
// CHECK: llvm.func @__ocml_tanh_f64(f64) -> f64 // CHECK: llvm.func @__ocml_tanh_f64(f64) -> f64
// CHECK-LABEL: func @gpu_tanh // CHECK-LABEL: func @gpu_tanh
builtin.func @gpu_tanh(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_tanh(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.tanh %arg_f32 : f32 %result32 = math.tanh %arg_f32 : f32
// CHECK: llvm.call @__ocml_tanh_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_tanh_f32(%{{.*}}) : (f32) -> f32
%result64 = math.tanh %arg_f64 : f64 %result64 = math.tanh %arg_f64 : f64
// CHECK: llvm.call @__ocml_tanh_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_tanh_f64(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_atan_f32(f32) -> f32 // CHECK: llvm.func @__ocml_atan_f32(f32) -> f32
// CHECK: llvm.func @__ocml_atan_f64(f64) -> f64 // CHECK: llvm.func @__ocml_atan_f64(f64) -> f64
// CHECK-LABEL: func @gpu_atan // CHECK-LABEL: func @gpu_atan
builtin.func @gpu_atan(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_atan(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.atan %arg_f32 : f32 %result32 = math.atan %arg_f32 : f32
// CHECK: llvm.call @__ocml_atan_f32(%{{.*}}) : (f32) -> f32 // CHECK: llvm.call @__ocml_atan_f32(%{{.*}}) : (f32) -> f32
%result64 = math.atan %arg_f64 : f64 %result64 = math.atan %arg_f64 : f64
// CHECK: llvm.call @__ocml_atan_f64(%{{.*}}) : (f64) -> f64 // CHECK: llvm.call @__ocml_atan_f64(%{{.*}}) : (f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_atan2_f32(f32, f32) -> f32 // CHECK: llvm.func @__ocml_atan2_f32(f32, f32) -> f32
// CHECK: llvm.func @__ocml_atan2_f64(f64, f64) -> f64 // CHECK: llvm.func @__ocml_atan2_f64(f64, f64) -> f64
// CHECK-LABEL: func @gpu_atan2 // CHECK-LABEL: func @gpu_atan2
builtin.func @gpu_atan2(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_atan2(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.atan2 %arg_f32, %arg_f32 : f32 %result32 = math.atan2 %arg_f32, %arg_f32 : f32
// CHECK: llvm.call @__ocml_atan2_f32(%{{.*}}) : (f32, f32) -> f32 // CHECK: llvm.call @__ocml_atan2_f32(%{{.*}}) : (f32, f32) -> f32
%result64 = math.atan2 %arg_f64, %arg_f64 : f64 %result64 = math.atan2 %arg_f64, %arg_f64 : f64
// CHECK: llvm.call @__ocml_atan2_f64(%{{.*}}) : (f64, f64) -> f64 // CHECK: llvm.call @__ocml_atan2_f64(%{{.*}}) : (f64, f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK: llvm.func @__ocml_pow_f32(f32, f32) -> f32 // CHECK: llvm.func @__ocml_pow_f32(f32, f32) -> f32
// CHECK: llvm.func @__ocml_pow_f64(f64, f64) -> f64 // CHECK: llvm.func @__ocml_pow_f64(f64, f64) -> f64
// CHECK-LABEL: func @gpu_pow // CHECK-LABEL: func @gpu_pow
builtin.func @gpu_pow(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) { func.func @gpu_pow(%arg_f32 : f32, %arg_f64 : f64) -> (f32, f64) {
%result32 = math.powf %arg_f32, %arg_f32 : f32 %result32 = math.powf %arg_f32, %arg_f32 : f32
// CHECK: llvm.call @__ocml_pow_f32(%{{.*}}, %{{.*}}) : (f32, f32) -> f32 // CHECK: llvm.call @__ocml_pow_f32(%{{.*}}, %{{.*}}) : (f32, f32) -> f32
%result64 = math.powf %arg_f64, %arg_f64 : f64 %result64 = math.powf %arg_f64, %arg_f64 : f64
// CHECK: llvm.call @__ocml_pow_f64(%{{.*}}, %{{.*}}) : (f64, f64) -> f64 // CHECK: llvm.call @__ocml_pow_f64(%{{.*}}, %{{.*}}) : (f64, f64) -> f64
func.return %result32, %result64 : f32, f64 func.return %result32, %result64 : f32, f64
} }
} }
Show All 11 Lines

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

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

mlir/test/Conversion/SCFToGPU/no_blocks_no_threads.mlir

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

mlir/test/Conversion/SCFToGPU/step_one.mlir

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

mlir/test/Conversion/SCFToGPU/step_positive.mlir

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

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

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

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

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

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

// RUN: mlir-opt --split-input-file -pass-pipeline="builtin.func(tosa-to-linalg)" %s -verify-diagnostics -o -| FileCheck %s // RUN: mlir-opt --split-input-file -pass-pipeline="func.func(tosa-to-linalg)" %s -verify-diagnostics -o -| FileCheck %s
// CHECK: #[[$MAP0:.*]] = affine_map<() -> ()> // CHECK: #[[$MAP0:.*]] = affine_map<() -> ()>
// CHECK-LABEL: @test_abs // CHECK-LABEL: @test_abs
func @test_abs(%arg0: tensor<f32>) -> tensor<f32> { func @test_abs(%arg0: tensor<f32>) -> tensor<f32> {
// CHECK: [[INIT:%.+]] = linalg.init_tensor [] : tensor<f32> // CHECK: [[INIT:%.+]] = linalg.init_tensor [] : tensor<f32>
// CHECK: [[GENERIC:%.+]] = linalg.generic {indexing_maps = [#[[$MAP0]], #[[$MAP0]]], iterator_types = []} ins(%arg0 : tensor<f32>) outs([[INIT]] : tensor<f32>) { // CHECK: [[GENERIC:%.+]] = linalg.generic {indexing_maps = [#[[$MAP0]], #[[$MAP0]]], iterator_types = []} ins(%arg0 : tensor<f32>) outs([[INIT]] : tensor<f32>) {
// CHECK: ^bb0(%arg1: f32, %arg2: f32): // CHECK: ^bb0(%arg1: f32, %arg2: f32):
▲ Show 20 Lines • Show All 1,853 Lines • Show Last 20 Lines

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

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

mlir/test/Conversion/VectorToROCDL/vector-to-rocdl.mlir

// RUN: mlir-opt %s -convert-vector-to-rocdl | FileCheck %s // RUN: mlir-opt %s -convert-vector-to-rocdl | FileCheck %s
gpu.module @test_read{ gpu.module @test_read{
builtin.func @transfer_readx2(%A : memref<?xf32>, %base: index) -> vector<2xf32> { func.func @transfer_readx2(%A : memref<?xf32>, %base: index) -> vector<2xf32> {
%f0 = arith.constant 0.0: f32 %f0 = arith.constant 0.0: f32
%f = vector.transfer_read %A[%base], %f0 %f = vector.transfer_read %A[%base], %f0
{permutation_map = affine_map<(d0) -> (d0)>} : {permutation_map = affine_map<(d0) -> (d0)>} :
memref<?xf32>, vector<2xf32> memref<?xf32>, vector<2xf32>
return %f: vector<2xf32> return %f: vector<2xf32>
} }
// CHECK-LABEL: @transfer_readx2 // CHECK-LABEL: @transfer_readx2
// CHECK: rocdl.buffer.load {{.*}} vector<2xf32> // CHECK: rocdl.buffer.load {{.*}} vector<2xf32>
builtin.func @transfer_readx4(%A : memref<?xf32>, %base: index) -> vector<4xf32> { func.func @transfer_readx4(%A : memref<?xf32>, %base: index) -> vector<4xf32> {
%f0 = arith.constant 0.0: f32 %f0 = arith.constant 0.0: f32
%f = vector.transfer_read %A[%base], %f0 %f = vector.transfer_read %A[%base], %f0
{permutation_map = affine_map<(d0) -> (d0)>} : {permutation_map = affine_map<(d0) -> (d0)>} :
memref<?xf32>, vector<4xf32> memref<?xf32>, vector<4xf32>
return %f: vector<4xf32> return %f: vector<4xf32>
} }
// CHECK-LABEL: @transfer_readx4 // CHECK-LABEL: @transfer_readx4
// CHECK: rocdl.buffer.load {{.*}} vector<4xf32> // CHECK: rocdl.buffer.load {{.*}} vector<4xf32>
builtin.func @transfer_read_dwordConfig(%A : memref<?xf32>, %base: index) -> vector<4xf32> { func.func @transfer_read_dwordConfig(%A : memref<?xf32>, %base: index) -> vector<4xf32> {
%f0 = arith.constant 0.0: f32 %f0 = arith.constant 0.0: f32
%f = vector.transfer_read %A[%base], %f0 %f = vector.transfer_read %A[%base], %f0
{permutation_map = affine_map<(d0) -> (d0)>} : {permutation_map = affine_map<(d0) -> (d0)>} :
memref<?xf32>, vector<4xf32> memref<?xf32>, vector<4xf32>
return %f: vector<4xf32> return %f: vector<4xf32>
} }
// CHECK-LABEL: @transfer_read_dwordConfig // CHECK-LABEL: @transfer_read_dwordConfig
// CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} // CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}}
// CHECK: [0, 0, -1, 159744] // CHECK: [0, 0, -1, 159744]
// CHECK: %[[i64:.*]] = llvm.ptrtoint %[[gep]] // CHECK: %[[i64:.*]] = llvm.ptrtoint %[[gep]]
// CHECK: llvm.insertelement %[[i64]] // CHECK: llvm.insertelement %[[i64]]
} }
gpu.module @test_write{ gpu.module @test_write{
builtin.func @transfer_writex2(%A : memref<?xf32>, %B : vector<2xf32>, %base: index) { func.func @transfer_writex2(%A : memref<?xf32>, %B : vector<2xf32>, %base: index) {
vector.transfer_write %B, %A[%base] vector.transfer_write %B, %A[%base]
{permutation_map = affine_map<(d0) -> (d0)>} : {permutation_map = affine_map<(d0) -> (d0)>} :
vector<2xf32>, memref<?xf32> vector<2xf32>, memref<?xf32>
return return
} }
// CHECK-LABEL: @transfer_writex2 // CHECK-LABEL: @transfer_writex2
// CHECK: rocdl.buffer.store {{.*}} vector<2xf32> // CHECK: rocdl.buffer.store {{.*}} vector<2xf32>
builtin.func @transfer_writex4(%A : memref<?xf32>, %B : vector<4xf32>, %base: index) { func.func @transfer_writex4(%A : memref<?xf32>, %B : vector<4xf32>, %base: index) {
vector.transfer_write %B, %A[%base] vector.transfer_write %B, %A[%base]
{permutation_map = affine_map<(d0) -> (d0)>} : {permutation_map = affine_map<(d0) -> (d0)>} :
vector<4xf32>, memref<?xf32> vector<4xf32>, memref<?xf32>
return return
} }
// CHECK-LABEL: @transfer_writex4 // CHECK-LABEL: @transfer_writex4
// CHECK: rocdl.buffer.store {{.*}} vector<4xf32> // CHECK: rocdl.buffer.store {{.*}} vector<4xf32>
builtin.func @transfer_write_dwordConfig(%A : memref<?xf32>, %B : vector<2xf32>, %base: index) { func.func @transfer_write_dwordConfig(%A : memref<?xf32>, %B : vector<2xf32>, %base: index) {
vector.transfer_write %B, %A[%base] vector.transfer_write %B, %A[%base]
{permutation_map = affine_map<(d0) -> (d0)>} : {permutation_map = affine_map<(d0) -> (d0)>} :
vector<2xf32>, memref<?xf32> vector<2xf32>, memref<?xf32>
return return
} }
// CHECK-LABEL: @transfer_write_dwordConfig // CHECK-LABEL: @transfer_write_dwordConfig
// CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} // CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}}
// CHECK: [0, 0, -1, 159744] // CHECK: [0, 0, -1, 159744]
// CHECK: %[[i64:.*]] = llvm.ptrtoint %[[gep]] // CHECK: %[[i64:.*]] = llvm.ptrtoint %[[gep]]
// CHECK: llvm.insertelement %[[i64]] // CHECK: llvm.insertelement %[[i64]]
} }

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

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

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

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

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

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

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

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

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

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

mlir/test/Dialect/Affine/canonicalize.mlir

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

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

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

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

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

mlir/test/Dialect/ControlFlow/canonicalize.mlir

// RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline='builtin.func(canonicalize)' -split-input-file | FileCheck --dump-input-context 20 %s // RUN: mlir-opt %s -allow-unregistered-dialect -pass-pipeline='func.func(canonicalize)' -split-input-file | FileCheck --dump-input-context 20 %s
/// Test the folding of BranchOp. /// Test the folding of BranchOp.
// CHECK-LABEL: func @br_folding( // CHECK-LABEL: func @br_folding(
func @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
▲ Show 20 Lines • Show All 458 Lines • Show Last 20 Lines

mlir/test/Dialect/LLVMIR/terminator.mlir

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

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

Show First 20 Lines • Show All 778 Lines • ▼ Show 20 Linesfunc @write_into_constant_via_alias(%v : vector<5xi32>,
// CHECK: vector.transfer_write // CHECK: vector.transfer_write
// CHECK-SAME: {__inplace_operands_attr__ = ["none", "true", "none"]} // CHECK-SAME: {__inplace_operands_attr__ = ["none", "true", "none"]}
%r = vector.transfer_write %v, %b[%s3] : vector<5xi32>, tensor<?xi32> %r = vector.transfer_write %v, %b[%s3] : vector<5xi32>, tensor<?xi32>
return %r : tensor<?xi32> return %r : tensor<?xi32>
} }
// ----- // -----
builtin.func @matmul_on_tensors( func.func @matmul_on_tensors(
%arg0: tensor<518x518xf32> {linalg.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, linalg.inplaceable = false}, %arg0: tensor<518x518xf32> {linalg.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, linalg.inplaceable = false},
%arg1: tensor<518x518xf32> {linalg.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, linalg.inplaceable = false}, %arg1: tensor<518x518xf32> {linalg.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, linalg.inplaceable = false},
%arg2: tensor<256x256xf32> {linalg.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, linalg.inplaceable = true}) %arg2: tensor<256x256xf32> {linalg.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, linalg.inplaceable = true})
-> tensor<256x256xf32> -> tensor<256x256xf32>
{ {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%cst_0 = arith.constant 0.000000e+00 : f32 %cst_0 = arith.constant 0.000000e+00 : f32
%cst_1 = arith.constant 1.000000e+00 : f32 %cst_1 = arith.constant 1.000000e+00 : f32
Show All 21 Linesfunc.func @matmul_on_tensors(
// CHECK: return // CHECK: return
// CHECK-SAME: __equivalent_func_args__ = [2] // CHECK-SAME: __equivalent_func_args__ = [2]
return %r : tensor<256x256xf32> return %r : tensor<256x256xf32>
} }
// ----- // -----
builtin.func @matmul_on_tensors( func.func @matmul_on_tensors(
%arg0: tensor<518x518xf32> {linalg.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, linalg.inplaceable = false}, %arg0: tensor<518x518xf32> {linalg.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, linalg.inplaceable = false},
%arg1: tensor<518x518xf32> {linalg.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, linalg.inplaceable = false}, %arg1: tensor<518x518xf32> {linalg.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, linalg.inplaceable = false},
%arg2: tensor<256x256xf32> {linalg.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, linalg.inplaceable = true}) %arg2: tensor<256x256xf32> {linalg.buffer_layout = affine_map<(d0, d1) -> (d0, d1)>, linalg.inplaceable = true})
-> tensor<256x256xf32> -> tensor<256x256xf32>
{ {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%cst_0 = arith.constant 0.000000e+00 : f32 %cst_0 = arith.constant 0.000000e+00 : f32
%cst_1 = arith.constant 1.000000e+00 : f32 %cst_1 = arith.constant 1.000000e+00 : f32
▲ Show 20 Lines • Show All 955 Lines • Show Last 20 Lines

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

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

mlir/test/Dialect/Linalg/detensorize_0d.mlir

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

mlir/test/Dialect/Linalg/detensorize_br_operands.mlir

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

mlir/test/Dialect/Linalg/detensorize_if.mlir

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

mlir/test/Dialect/Linalg/detensorize_trivial.mlir

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

mlir/test/Dialect/Linalg/detensorize_while.mlir

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

mlir/test/Dialect/Linalg/detensorize_while_impure_cf.mlir

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

mlir/test/Dialect/Linalg/detensorize_while_pure_cf.mlir

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

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

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

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

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

mlir/test/Dialect/Linalg/fusion-sequence.mlir

// RUN: mlir-opt -pass-pipeline="builtin.func(test-linalg-tile-and-fuse{tile-sizes=16,32,64}),resolve-shaped-type-result-dims,canonicalize,cse" -split-input-file %s | FileCheck %s // RUN: mlir-opt -pass-pipeline="func.func(test-linalg-tile-and-fuse{tile-sizes=16,32,64}),resolve-shaped-type-result-dims,canonicalize,cse" -split-input-file %s | FileCheck %s
module { module {
func @three_op_fusion(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, func @three_op_fusion(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>,
%arg2: memref<?xf32>, %arg3 : memref<?x?xf32>) { %arg2: memref<?xf32>, %arg3 : memref<?x?xf32>) {
%cst = arith.constant 0.000000e+00 : f32 %cst = arith.constant 0.000000e+00 : f32
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%d0 = memref.dim %arg0, %c0 : memref<?x?xf32> %d0 = memref.dim %arg0, %c0 : memref<?x?xf32>
▲ Show 20 Lines • Show All 248 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/tile-and-fuse-no-fuse.mlir

// RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-op=linalg.matmul fuse tile-sizes=0,0,0 run-enable-pass=false" -split-input-file | FileCheck %s // RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-op=linalg.matmul fuse tile-sizes=0,0,0 run-enable-pass=false" -split-input-file | FileCheck %s
builtin.func @no_fuse_gemm(%arg0 : tensor<?x?xf32>, %arg1 : tensor<?x?xf32>) -> tensor<?x?xf32> { func.func @no_fuse_gemm(%arg0 : tensor<?x?xf32>, %arg1 : 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 0.0 : f32 %cst = arith.constant 0.0 : f32
%d0 = tensor.dim %arg0, %c0 : tensor<?x?xf32> %d0 = tensor.dim %arg0, %c0 : tensor<?x?xf32>
%d1 = tensor.dim %arg1, %c1 : tensor<?x?xf32> %d1 = tensor.dim %arg1, %c1 : tensor<?x?xf32>
%init = linalg.init_tensor [%d0, %d1] : tensor<?x?xf32> %init = linalg.init_tensor [%d0, %d1] : tensor<?x?xf32>
%fill = linalg.fill ins(%cst : f32) outs(%init : tensor<?x?xf32>) -> tensor<?x?xf32> %fill = linalg.fill ins(%cst : f32) outs(%init : tensor<?x?xf32>) -> tensor<?x?xf32>
%result = linalg.matmul ins(%arg0, %arg1 : tensor<?x?xf32>, tensor<?x?xf32>) %result = linalg.matmul ins(%arg0, %arg1 : tensor<?x?xf32>, tensor<?x?xf32>)
outs(%fill : tensor<?x?xf32>) -> tensor<?x?xf32> outs(%fill : tensor<?x?xf32>) -> tensor<?x?xf32>
return %result : tensor<?x?xf32> return %result : tensor<?x?xf32>
} }
// CHECK-LABEL: @no_fuse_gemm( // CHECK-LABEL: @no_fuse_gemm(
// CHECK-NOT: scf.for // CHECK-NOT: scf.for
// CHECK: linalg.fill // CHECK: linalg.fill
// CHECK-NOT: scf.for // CHECK-NOT: scf.for
// CHECK: linalg.matmul // CHECK: linalg.matmul

mlir/test/Dialect/Linalg/tile-and-fuse-on-tensors.mlir

// RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-op=linalg.matmul fuse tile-sizes=5,4,7 tile-interchange=1,0,2 run-enable-pass=false" -cse -split-input-file | FileCheck --check-prefix=MATMUL %s // RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-op=linalg.matmul fuse tile-sizes=5,4,7 tile-interchange=1,0,2 run-enable-pass=false" -cse -split-input-file | FileCheck --check-prefix=MATMUL %s
// RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-op=linalg.generic fuse tile-sizes=5,4,7 tile-interchange=1,0,2 run-enable-pass=false" -cse -split-input-file | FileCheck --check-prefix=GENERIC %s // RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-op=linalg.generic fuse tile-sizes=5,4,7 tile-interchange=1,0,2 run-enable-pass=false" -cse -split-input-file | FileCheck --check-prefix=GENERIC %s
// MATMUL-DAG: #[[MAP0:.*]] = affine_map<(d0) -> (5, -d0 + 24)> // MATMUL-DAG: #[[MAP0:.*]] = affine_map<(d0) -> (5, -d0 + 24)>
// MATMUL-DAG: #[[MAP1:.*]] = affine_map<(d0) -> (7, -d0 + 12)> // MATMUL-DAG: #[[MAP1:.*]] = affine_map<(d0) -> (7, -d0 + 12)>
// MATMUL-DAG: #[[MAP2:.*]] = affine_map<(d0, d1) -> (d0, -d1 + 24)> // MATMUL-DAG: #[[MAP2:.*]] = affine_map<(d0, d1) -> (d0, -d1 + 24)>
// MATMUL-DAG: #[[MAP3:.*]] = affine_map<(d0, d1) -> (d0, -d1 + 12)> // MATMUL-DAG: #[[MAP3:.*]] = affine_map<(d0, d1) -> (d0, -d1 + 12)>
// MATMUL: fuse_input // MATMUL: fuse_input
// MATMUL-SAME: %[[ARG0:[0-9a-zA-Z]*]]: tensor<24x12xf32> // MATMUL-SAME: %[[ARG0:[0-9a-zA-Z]*]]: tensor<24x12xf32>
builtin.func @fuse_input(%arg0: tensor<24x12xf32>, func.func @fuse_input(%arg0: tensor<24x12xf32>,
%arg1: tensor<12x25xf32>, %arg1: tensor<12x25xf32>,
%arg2: tensor<24x25xf32>) -> tensor<24x25xf32> { %arg2: tensor<24x25xf32>) -> tensor<24x25xf32> {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c12 = arith.constant 12 : index %c12 = arith.constant 12 : index
%c25 = arith.constant 25 : index %c25 = arith.constant 25 : index
%c24 = arith.constant 24 : index %c24 = arith.constant 24 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%cst = arith.constant 0.000000e+00 : f32 %cst = arith.constant 0.000000e+00 : f32
Show All 19 Lines
// ----- // -----
// MATMUL-DAG: #[[MAP0:.*]] = affine_map<(d0) -> (5, -d0 + 24)> // MATMUL-DAG: #[[MAP0:.*]] = affine_map<(d0) -> (5, -d0 + 24)>
// MATMUL-DAG: #[[MAP1:.*]] = affine_map<(d0) -> (4, -d0 + 25)> // MATMUL-DAG: #[[MAP1:.*]] = affine_map<(d0) -> (4, -d0 + 25)>
// MATMUL: fuse_output // MATMUL: fuse_output
// MATMUL-SAME: %[[ARG2:[0-9a-zA-Z]*]]: tensor<24x25xf32> // MATMUL-SAME: %[[ARG2:[0-9a-zA-Z]*]]: tensor<24x25xf32>
builtin.func @fuse_output(%arg0: tensor<24x12xf32>, func.func @fuse_output(%arg0: tensor<24x12xf32>,
%arg1: tensor<12x25xf32>, %arg1: tensor<12x25xf32>,
%arg2: tensor<24x25xf32>) -> tensor<24x25xf32> { %arg2: tensor<24x25xf32>) -> tensor<24x25xf32> {
// MATMUL-DAG: %[[C0:.*]] = arith.constant 0 : index // MATMUL-DAG: %[[C0:.*]] = arith.constant 0 : index
// MATMUL-DAG: %[[C1:.*]] = arith.constant 1 : index // MATMUL-DAG: %[[C1:.*]] = arith.constant 1 : index
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c12 = arith.constant 12 : index %c12 = arith.constant 12 : index
%c25 = arith.constant 25 : index %c25 = arith.constant 25 : index
%c24 = arith.constant 24 : index %c24 = arith.constant 24 : index
Show All 35 Lines
// MATMUL-DAG: #[[MAP2:.*]] = affine_map<(d0, d1) -> (d0, -d1 + 25)> // MATMUL-DAG: #[[MAP2:.*]] = affine_map<(d0, d1) -> (d0, -d1 + 25)>
// MATMUL-DAG: #[[MAP3:.*]] = affine_map<(d0, d1) -> (d0, -d1 + 12)> // MATMUL-DAG: #[[MAP3:.*]] = affine_map<(d0, d1) -> (d0, -d1 + 12)>
#map0 = affine_map<(d0, d1, d2) -> (d0, d1, d2)> #map0 = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
#map1 = affine_map<(d0, d1, d2) -> (d0, d2)> #map1 = affine_map<(d0, d1, d2) -> (d0, d2)>
// MATMUL: fuse_reduction // MATMUL: fuse_reduction
// MATMUL-SAME: %[[ARG1:[0-9a-zA-Z]*]]: tensor<12x25xf32> // MATMUL-SAME: %[[ARG1:[0-9a-zA-Z]*]]: tensor<12x25xf32>
// MATMUL-SAME: %[[ARG3:[0-9a-zA-Z]*]]: tensor<12x7x25xf32> // MATMUL-SAME: %[[ARG3:[0-9a-zA-Z]*]]: tensor<12x7x25xf32>
builtin.func @fuse_reduction(%arg0: tensor<24x12xf32>, func.func @fuse_reduction(%arg0: tensor<24x12xf32>,
%arg1: tensor<12x25xf32>, %arg1: tensor<12x25xf32>,
%arg2: tensor<24x25xf32>, %arg2: tensor<24x25xf32>,
%arg3: tensor<12x7x25xf32>) -> tensor<24x25xf32> { %arg3: tensor<12x7x25xf32>) -> tensor<24x25xf32> {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c12 = arith.constant 12 : index %c12 = arith.constant 12 : index
%c25 = arith.constant 25 : index %c25 = arith.constant 25 : index
%c24 = arith.constant 24 : index %c24 = arith.constant 24 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
Show All 27 Lines
// ----- // -----
#map0 = affine_map<(d0, d1) -> (d1, d0)> #map0 = affine_map<(d0, d1) -> (d1, d0)>
#map1 = affine_map<(d0, d1) -> (d0, d1)> #map1 = affine_map<(d0, d1) -> (d0, d1)>
// MATMUL: fuse_transposed // MATMUL: fuse_transposed
// MATMUL-SAME: %[[ARG0:[0-9a-zA-Z]*]]: tensor<24x12xf32> // MATMUL-SAME: %[[ARG0:[0-9a-zA-Z]*]]: tensor<24x12xf32>
// MATMUL-SAME: %[[ARG3:[0-9a-zA-Z]*]]: tensor<12x24xf32> // MATMUL-SAME: %[[ARG3:[0-9a-zA-Z]*]]: tensor<12x24xf32>
builtin.func @fuse_transposed(%arg0: tensor<24x12xf32>, func.func @fuse_transposed(%arg0: tensor<24x12xf32>,
%arg1: tensor<12x25xf32>, %arg1: tensor<12x25xf32>,
%arg2: tensor<24x25xf32>, %arg2: tensor<24x25xf32>,
%arg3: tensor<12x24xf32>) -> tensor<24x25xf32> { %arg3: tensor<12x24xf32>) -> tensor<24x25xf32> {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c12 = arith.constant 12 : index %c12 = arith.constant 12 : index
%c25 = arith.constant 25 : index %c25 = arith.constant 25 : index
%c24 = arith.constant 24 : index %c24 = arith.constant 24 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
Show All 18 Linesfunc.func @fuse_transposed(%arg0: tensor<24x12xf32>,
return %1 : tensor<24x25xf32> return %1 : tensor<24x25xf32>
} }
// ----- // -----
// MATMUL: fuse_input_and_output // MATMUL: fuse_input_and_output
// MATMUL-SAME: %[[ARG0:[0-9a-zA-Z]*]]: tensor<24x12xf32> // MATMUL-SAME: %[[ARG0:[0-9a-zA-Z]*]]: tensor<24x12xf32>
// MATMUL-SAME: %[[ARG2:[0-9a-zA-Z]*]]: tensor<24x25xf32> // MATMUL-SAME: %[[ARG2:[0-9a-zA-Z]*]]: tensor<24x25xf32>
builtin.func @fuse_input_and_output(%arg0: tensor<24x12xf32>, func.func @fuse_input_and_output(%arg0: tensor<24x12xf32>,
%arg1: tensor<12x25xf32>, %arg1: tensor<12x25xf32>,
%arg2: tensor<24x25xf32>) -> tensor<24x25xf32> { %arg2: tensor<24x25xf32>) -> tensor<24x25xf32> {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c12 = arith.constant 12 : index %c12 = arith.constant 12 : index
%c25 = arith.constant 25 : index %c25 = arith.constant 25 : index
%c24 = arith.constant 24 : index %c24 = arith.constant 24 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%cst = arith.constant 0.000000e+00 : f32 %cst = arith.constant 0.000000e+00 : f32
Show All 18 Lines
// ----- // -----
// MATMUL-DAG: #[[MAP0:.*]] = affine_map<(d0, d1) -> (d0 + d1)> // MATMUL-DAG: #[[MAP0:.*]] = affine_map<(d0, d1) -> (d0 + d1)>
#map0 = affine_map<(d0, d1) -> (d1, d0)> #map0 = affine_map<(d0, d1) -> (d1, d0)>
// MATMUL: fuse_indexed // MATMUL: fuse_indexed
// MATMUL-SAME: %[[ARG1:[0-9a-zA-Z]*]]: tensor<12x25xi32> // MATMUL-SAME: %[[ARG1:[0-9a-zA-Z]*]]: tensor<12x25xi32>
builtin.func @fuse_indexed(%arg0: tensor<24x12xi32>, func.func @fuse_indexed(%arg0: tensor<24x12xi32>,
%arg1: tensor<12x25xi32>, %arg1: tensor<12x25xi32>,
%arg2: tensor<24x25xi32>) -> tensor<24x25xi32> { %arg2: tensor<24x25xi32>) -> tensor<24x25xi32> {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c12 = arith.constant 12 : index %c12 = arith.constant 12 : index
%c25 = arith.constant 25 : index %c25 = arith.constant 25 : index
%c24 = arith.constant 24 : index %c24 = arith.constant 24 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%0 = linalg.generic {indexing_maps = [#map0], iterator_types = ["parallel", "parallel"]} outs(%arg1 : tensor<12x25xi32>) { %0 = linalg.generic {indexing_maps = [#map0], iterator_types = ["parallel", "parallel"]} outs(%arg1 : tensor<12x25xi32>) {
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/tile-and-fuse-sequence-on-tensors.mlir

// RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-op=linalg.conv_2d fuse tile-sizes=4,4,0,0 tile-interchange=0,1,2,3 run-enable-pass=false" -split-input-file | FileCheck --check-prefix=CONV %s // RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-op=linalg.conv_2d fuse tile-sizes=4,4,0,0 tile-interchange=0,1,2,3 run-enable-pass=false" -split-input-file | FileCheck --check-prefix=CONV %s
// RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-op=linalg.matmul fuse tile-sizes=4,4,0 tile-interchange=0,1,2 run-enable-pass=false" -split-input-file | FileCheck --check-prefix=MATMUL %s // RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-op=linalg.matmul fuse tile-sizes=4,4,0 tile-interchange=0,1,2 run-enable-pass=false" -split-input-file | FileCheck --check-prefix=MATMUL %s
// CONV: fuse_conv_chain // CONV: fuse_conv_chain
// CONV-SAME: %[[ARG0:[0-9a-zA-Z]*]]: tensor<2x2xf32> // CONV-SAME: %[[ARG0:[0-9a-zA-Z]*]]: tensor<2x2xf32>
// CONV-SAME: %[[ARG1:[0-9a-zA-Z]*]]: tensor<11x11xf32> // CONV-SAME: %[[ARG1:[0-9a-zA-Z]*]]: tensor<11x11xf32>
// CONV-SAME: %[[ARG2:[0-9a-zA-Z]*]]: tensor<10x10xf32> // CONV-SAME: %[[ARG2:[0-9a-zA-Z]*]]: tensor<10x10xf32>
// CONV-SAME: %[[ARG3:[0-9a-zA-Z]*]]: tensor<9x9xf32> // CONV-SAME: %[[ARG3:[0-9a-zA-Z]*]]: tensor<9x9xf32>
// CONV-SAME: %[[ARG4:[0-9a-zA-Z]*]]: tensor<8x8xf32> // CONV-SAME: %[[ARG4:[0-9a-zA-Z]*]]: tensor<8x8xf32>
builtin.func @fuse_conv_chain(%arg0: tensor<2x2xf32>, func.func @fuse_conv_chain(%arg0: tensor<2x2xf32>,
%arg1: tensor<11x11xf32>, %arg1: tensor<11x11xf32>,
%arg2: tensor<10x10xf32>, %arg2: tensor<10x10xf32>,
%arg3: tensor<9x9xf32>, %arg3: tensor<9x9xf32>,
%arg4: tensor<8x8xf32>) -> tensor<8x8xf32> { %arg4: tensor<8x8xf32>) -> tensor<8x8xf32> {
%cst = arith.constant 1.0 : f32 %cst = arith.constant 1.0 : f32
// Do not tile the filter fill since the filter dimensions are not tiled. // Do not tile the filter fill since the filter dimensions are not tiled.
// CONV: %[[T0:.*]] = linalg.fill ins(%{{.*}}{{.*}}outs(%[[ARG0]] // CONV: %[[T0:.*]] = linalg.fill ins(%{{.*}}{{.*}}outs(%[[ARG0]]
Show All 28 Linesfunc.func @fuse_conv_chain(%arg0: tensor<2x2xf32>,
%6 = linalg.conv_2d ins(%4, %0 : tensor<9x9xf32>, tensor<2x2xf32>) outs(%5 : tensor<8x8xf32>) -> tensor<8x8xf32> %6 = linalg.conv_2d ins(%4, %0 : tensor<9x9xf32>, tensor<2x2xf32>) outs(%5 : tensor<8x8xf32>) -> tensor<8x8xf32>
return %6 : tensor<8x8xf32> return %6 : tensor<8x8xf32>
} }
// ----- // -----
// MATMUL: fuse_matmul_chain // MATMUL: fuse_matmul_chain
// MATMUL-SAME: %[[ARG0:[0-9a-zA-Z]*]]: tensor<8x8xf32> // MATMUL-SAME: %[[ARG0:[0-9a-zA-Z]*]]: tensor<8x8xf32>
builtin.func @fuse_matmul_chain(%arg0: tensor<8x8xf32>) -> tensor<8x8xf32> { func.func @fuse_matmul_chain(%arg0: tensor<8x8xf32>) -> tensor<8x8xf32> {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c12 = arith.constant 12 : index %c12 = arith.constant 12 : index
%c25 = arith.constant 25 : index %c25 = arith.constant 25 : index
%c24 = arith.constant 24 : index %c24 = arith.constant 24 : index
%c4 = arith.constant 4 : index %c4 = arith.constant 4 : index
%cst = arith.constant 0.000000e+00 : f32 %cst = arith.constant 0.000000e+00 : f32
// Do not tile rhs fill of the producer matmul since none of its loop dimension is tiled. // Do not tile rhs fill of the producer matmul since none of its loop dimension is tiled.
Show All 21 Lines

mlir/test/Dialect/Quant/canonicalize.mlir

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

mlir/test/Dialect/SCF/canonicalize.mlir

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

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

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

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

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

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

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

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

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

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

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

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

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

mlir/test/Dialect/Shape/invalid.mlir

Show First 20 Lines • Show All 166 Lines • ▼ Show 20 Lines
// Test using an unsupported shape.lib attribute type. // Test using an unsupported shape.lib attribute type.
// expected-error@+1 {{only SymbolRefAttr allowed in shape.lib attribute array}} // expected-error@+1 {{only SymbolRefAttr allowed in shape.lib attribute array}}
module attributes {shape.lib = [@shape_lib, "shape_lib"]} { module attributes {shape.lib = [@shape_lib, "shape_lib"]} {
shape.function_library @shape_lib { shape.function_library @shape_lib {
// Test shape function that returns the shape of input arg as result shape. // Test shape function that returns the shape of input arg as result shape.
builtin.func @same_result_shape(%arg: !shape.value_shape) -> !shape.shape { func.func @same_result_shape(%arg: !shape.value_shape) -> !shape.shape {
%0 = shape.shape_of %arg : !shape.value_shape -> !shape.shape %0 = shape.shape_of %arg : !shape.value_shape -> !shape.shape
return %0 : !shape.shape return %0 : !shape.shape
} }
} mapping { } mapping {
test.same_operand_result_type = @same_result_shape test.same_operand_result_type = @same_result_shape
} }
} }
// ----- // -----
// Test that duplicate op to shape function mappings are flagged, this uses // Test that duplicate op to shape function mappings are flagged, this uses
// the same library twice for easy overlap. // the same library twice for easy overlap.
// expected-error@+1 {{only one op to shape mapping allowed}} // expected-error@+1 {{only one op to shape mapping allowed}}
module attributes {shape.lib = [@shape_lib, @shape_lib]} { module attributes {shape.lib = [@shape_lib, @shape_lib]} {
shape.function_library @shape_lib { shape.function_library @shape_lib {
// Test shape function that returns the shape of input arg as result shape. // Test shape function that returns the shape of input arg as result shape.
builtin.func @same_result_shape(%arg: !shape.value_shape) -> !shape.shape { func.func @same_result_shape(%arg: !shape.value_shape) -> !shape.shape {
%0 = shape.shape_of %arg : !shape.value_shape -> !shape.shape %0 = shape.shape_of %arg : !shape.value_shape -> !shape.shape
return %0 : !shape.shape return %0 : !shape.shape
} }
} mapping { } mapping {
test.same_operand_result_type = @same_result_shape test.same_operand_result_type = @same_result_shape
} }
} }
// ----- // -----
// Test that duplicate op to shape function mappings are flagged (this is // Test that duplicate op to shape function mappings are flagged (this is
// more an invariant of using the dictionary attribute here than anything // more an invariant of using the dictionary attribute here than anything
// specific to function library op). // specific to function library op).
module attributes {shape.lib = [@shape_lib]} { module attributes {shape.lib = [@shape_lib]} {
shape.function_library @shape_lib { shape.function_library @shape_lib {
// Test shape function that returns the shape of input arg as result shape. // Test shape function that returns the shape of input arg as result shape.
builtin.func @same_result_shape(%arg: !shape.value_shape) -> !shape.shape { func.func @same_result_shape(%arg: !shape.value_shape) -> !shape.shape {
%0 = shape.shape_of %arg : !shape.value_shape -> !shape.shape %0 = shape.shape_of %arg : !shape.value_shape -> !shape.shape
return %0 : !shape.shape return %0 : !shape.shape
} }
} mapping { } mapping {
// expected-error @+2 {{duplicate key}} // expected-error @+2 {{duplicate key}}
test.same_operand_result_type = @same_result_shape, test.same_operand_result_type = @same_result_shape,
test.same_operand_result_type = @same_result_shape test.same_operand_result_type = @same_result_shape
} }
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

mlir/test/Dialect/Tensor/invalid.mlir

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Linesfunc @tensor.generate(%m : index, %n : index)
} : tensor<?x3x?xf32> } : tensor<?x3x?xf32>
return %tnsr : tensor<?x3x?xf32> return %tnsr : tensor<?x3x?xf32>
} }
// ----- // -----
func @tensor.generate(%m : index, %n : index) func @tensor.generate(%m : index, %n : index)
-> tensor<?x3x?xf32> { -> tensor<?x3x?xf32> {
// expected-error @+4 {{'func.return' op expects parent op 'builtin.func'}} // expected-error @+4 {{'func.return' op expects parent op 'func.func'}}
%tnsr = tensor.generate %m, %n { %tnsr = tensor.generate %m, %n {
^bb0(%i : index, %j : index, %k : index): ^bb0(%i : index, %j : index, %k : index):
%elem = arith.constant 8.0 : f32 %elem = arith.constant 8.0 : f32
return %elem : f32 return %elem : f32
} : tensor<?x3x?xf32> } : tensor<?x3x?xf32>
return %tnsr : tensor<?x3x?xf32> return %tnsr : tensor<?x3x?xf32>
} }
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines

mlir/test/Dialect/Vector/canonicalize.mlir

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

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

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

mlir/test/IR/generic-visitors-interrupt.mlir

// RUN: mlir-opt -test-generic-ir-visitors-interrupt -allow-unregistered-dialect -split-input-file %s | FileCheck %s // RUN: mlir-opt -test-generic-ir-visitors-interrupt -allow-unregistered-dialect -split-input-file %s | FileCheck %s
// Walk is interrupted before visiting "foo" // Walk is interrupted before visiting "foo"
func @main(%arg0: f32) -> f32 { func @main(%arg0: f32) -> f32 {
%v1 = "foo"() {interrupt_before_all = true} : () -> f32 %v1 = "foo"() {interrupt_before_all = true} : () -> f32
%v2 = arith.addf %v1, %arg0 : f32 %v2 = arith.addf %v1, %arg0 : f32
return %v2 : f32 return %v2 : f32
} }
// CHECK: step 0 op 'builtin.module' before all regions // CHECK: step 0 op 'builtin.module' before all regions
// CHECK: step 1 op 'builtin.func' before all regions // CHECK: step 1 op 'func.func' before all regions
// CHECK: step 2 walk was interrupted // CHECK: step 2 walk was interrupted
// ----- // -----
// Walk is interrupted after visiting "foo" (which has a single empty region) // Walk is interrupted after visiting "foo" (which has a single empty region)
func @main(%arg0: f32) -> f32 { func @main(%arg0: f32) -> f32 {
%v1 = "foo"() ({ "bar"() : ()-> () }) {interrupt_after_all = true} : () -> f32 %v1 = "foo"() ({ "bar"() : ()-> () }) {interrupt_after_all = true} : () -> f32
%v2 = arith.addf %v1, %arg0 : f32 %v2 = arith.addf %v1, %arg0 : f32
return %v2 : f32 return %v2 : f32
} }
// CHECK: step 0 op 'builtin.module' before all regions // CHECK: step 0 op 'builtin.module' before all regions
// CHECK: step 1 op 'builtin.func' before all regions // CHECK: step 1 op 'func.func' before all regions
// CHECK: step 2 op 'foo' before all regions // CHECK: step 2 op 'foo' before all regions
// CHECK: step 3 op 'bar' before all regions // CHECK: step 3 op 'bar' before all regions
// CHECK: step 4 walk was interrupted // CHECK: step 4 walk was interrupted
// ----- // -----
// Walk is interrupted after visiting "foo"'s 1st region. // Walk is interrupted after visiting "foo"'s 1st region.
func @main(%arg0: f32) -> f32 { func @main(%arg0: f32) -> f32 {
%v1 = "foo"() ({ %v1 = "foo"() ({
"bar0"() : () -> () "bar0"() : () -> ()
}, { }, {
"bar1"() : () -> () "bar1"() : () -> ()
}) {interrupt_after_region = 0} : () -> f32 }) {interrupt_after_region = 0} : () -> f32
%v2 = arith.addf %v1, %arg0 : f32 %v2 = arith.addf %v1, %arg0 : f32
return %v2 : f32 return %v2 : f32
} }
// CHECK: step 0 op 'builtin.module' before all regions // CHECK: step 0 op 'builtin.module' before all regions
// CHECK: step 1 op 'builtin.func' before all regions // CHECK: step 1 op 'func.func' before all regions
// CHECK: step 2 op 'foo' before all regions // CHECK: step 2 op 'foo' before all regions
// CHECK: step 3 op 'bar0' before all regions // CHECK: step 3 op 'bar0' before all regions
// CHECK: step 4 walk was interrupted // CHECK: step 4 walk was interrupted
// ----- // -----
// Test static filtering. // Test static filtering.
func @main() { func @main() {
"foo"() : () -> () "foo"() : () -> ()
"test.two_region_op"()( "test.two_region_op"()(
{"work"() : () -> ()}, {"work"() : () -> ()},
{"work"() : () -> ()} {"work"() : () -> ()}
) {interrupt_after_all = true} : () -> () ) {interrupt_after_all = true} : () -> ()
return return
} }
// CHECK: step 0 op 'builtin.module' before all regions // CHECK: step 0 op 'builtin.module' before all regions
// CHECK: step 1 op 'builtin.func' before all regions // CHECK: step 1 op 'func.func' before all regions
// CHECK: step 2 op 'foo' before all regions // CHECK: step 2 op 'foo' before all regions
// CHECK: step 3 op 'test.two_region_op' before all regions // CHECK: step 3 op 'test.two_region_op' before all regions
// CHECK: step 4 op 'work' before all regions // CHECK: step 4 op 'work' before all regions
// CHECK: step 5 op 'test.two_region_op' before region #1 // CHECK: step 5 op 'test.two_region_op' before region #1
// CHECK: step 6 op 'work' before all regions // CHECK: step 6 op 'work' before all regions
// CHECK: step 7 walk was interrupted // CHECK: step 7 walk was interrupted
// CHECK: step 8 op 'test.two_region_op' before all regions // CHECK: step 8 op 'test.two_region_op' before all regions
// CHECK: step 9 op 'test.two_region_op' before region #1 // CHECK: step 9 op 'test.two_region_op' before region #1
// CHECK: step 10 walk was interrupted // CHECK: step 10 walk was interrupted
// ----- // -----
// Test static filtering. // Test static filtering.
func @main() { func @main() {
"foo"() : () -> () "foo"() : () -> ()
"test.two_region_op"()( "test.two_region_op"()(
{"work"() : () -> ()}, {"work"() : () -> ()},
{"work"() : () -> ()} {"work"() : () -> ()}
) {interrupt_after_region = 0} : () -> () ) {interrupt_after_region = 0} : () -> ()
return return
} }
// CHECK: step 0 op 'builtin.module' before all regions // CHECK: step 0 op 'builtin.module' before all regions
// CHECK: step 1 op 'builtin.func' before all regions // CHECK: step 1 op 'func.func' before all regions
// CHECK: step 2 op 'foo' before all regions // CHECK: step 2 op 'foo' before all regions
// CHECK: step 3 op 'test.two_region_op' before all regions // CHECK: step 3 op 'test.two_region_op' before all regions
// CHECK: step 4 op 'work' before all regions // CHECK: step 4 op 'work' before all regions
// CHECK: step 5 walk was interrupted // CHECK: step 5 walk was interrupted
// CHECK: step 6 op 'test.two_region_op' before all regions // CHECK: step 6 op 'test.two_region_op' before all regions
// CHECK: step 7 walk was interrupted // CHECK: step 7 walk was interrupted
// ----- // -----
// Test skipping. // Test skipping.
// Walk is skipped before visiting "foo". // Walk is skipped before visiting "foo".
func @main(%arg0: f32) -> f32 { func @main(%arg0: f32) -> f32 {
%v1 = "foo"() ({ %v1 = "foo"() ({
"bar0"() : () -> () "bar0"() : () -> ()
}, { }, {
"bar1"() : () -> () "bar1"() : () -> ()
}) {skip_before_all = true} : () -> f32 }) {skip_before_all = true} : () -> f32
%v2 = arith.addf %v1, %arg0 : f32 %v2 = arith.addf %v1, %arg0 : f32
return %v2 : f32 return %v2 : f32
} }
// CHECK: step 0 op 'builtin.module' before all regions // CHECK: step 0 op 'builtin.module' before all regions
// CHECK: step 1 op 'builtin.func' before all regions // CHECK: step 1 op 'func.func' before all regions
// CHECK: step 2 op 'arith.addf' before all regions // CHECK: step 2 op 'arith.addf' before all regions
// CHECK: step 3 op 'func.return' before all regions // CHECK: step 3 op 'func.return' before all regions
// CHECK: step 4 op 'builtin.func' after all regions // CHECK: step 4 op 'func.func' after all regions
// CHECK: step 5 op 'builtin.module' after all regions // CHECK: step 5 op 'builtin.module' after all regions
// ----- // -----
// Walk is skipped after visiting all regions of "foo". // Walk is skipped after visiting all regions of "foo".
func @main(%arg0: f32) -> f32 { func @main(%arg0: f32) -> f32 {
%v1 = "foo"() ({ %v1 = "foo"() ({
"bar0"() : () -> () "bar0"() : () -> ()
}, { }, {
"bar1"() : () -> () "bar1"() : () -> ()
}) {skip_after_all = true} : () -> f32 }) {skip_after_all = true} : () -> f32
%v2 = arith.addf %v1, %arg0 : f32 %v2 = arith.addf %v1, %arg0 : f32
return %v2 : f32 return %v2 : f32
} }
// CHECK: step 0 op 'builtin.module' before all regions // CHECK: step 0 op 'builtin.module' before all regions
// CHECK: step 1 op 'builtin.func' before all regions // CHECK: step 1 op 'func.func' before all regions
// CHECK: step 2 op 'foo' before all regions // CHECK: step 2 op 'foo' before all regions
// CHECK: step 3 op 'bar0' before all regions // CHECK: step 3 op 'bar0' before all regions
// CHECK: step 4 op 'foo' before region #1 // CHECK: step 4 op 'foo' before region #1
// CHECK: step 5 op 'bar1' before all regions // CHECK: step 5 op 'bar1' before all regions
// CHECK: step 6 op 'arith.addf' before all regions // CHECK: step 6 op 'arith.addf' before all regions
// CHECK: step 7 op 'func.return' before all regions // CHECK: step 7 op 'func.return' before all regions
// CHECK: step 8 op 'builtin.func' after all regions // CHECK: step 8 op 'func.func' after all regions
// CHECK: step 9 op 'builtin.module' after all regions // CHECK: step 9 op 'builtin.module' after all regions
// ----- // -----
// Walk is skipped after visiting first region of "foo". // Walk is skipped after visiting first region of "foo".
func @main(%arg0: f32) -> f32 { func @main(%arg0: f32) -> f32 {
%v1 = "foo"() ({ %v1 = "foo"() ({
"bar0"() : () -> () "bar0"() : () -> ()
}, { }, {
"bar1"() : () -> () "bar1"() : () -> ()
}) {skip_after_region = 0} : () -> f32 }) {skip_after_region = 0} : () -> f32
%v2 = arith.addf %v1, %arg0 : f32 %v2 = arith.addf %v1, %arg0 : f32
return %v2 : f32 return %v2 : f32
} }
// CHECK: step 0 op 'builtin.module' before all regions // CHECK: step 0 op 'builtin.module' before all regions
// CHECK: step 1 op 'builtin.func' before all regions // CHECK: step 1 op 'func.func' before all regions
// CHECK: step 2 op 'foo' before all regions // CHECK: step 2 op 'foo' before all regions
// CHECK: step 3 op 'bar0' before all regions // CHECK: step 3 op 'bar0' before all regions
// CHECK: step 4 op 'arith.addf' before all regions // CHECK: step 4 op 'arith.addf' before all regions
// CHECK: step 5 op 'func.return' before all regions // CHECK: step 5 op 'func.return' before all regions
// CHECK: step 6 op 'builtin.func' after all regions // CHECK: step 6 op 'func.func' after all regions
// CHECK: step 7 op 'builtin.module' after all regions // CHECK: step 7 op 'builtin.module' after all regions

mlir/test/IR/generic-visitors.mlir

Show All 14 Lines scf.if %cond {
"use2"(%i) : (index) -> () "use2"(%i) : (index) -> ()
} }
"use3"(%i) : (index) -> () "use3"(%i) : (index) -> ()
} }
return return
} }
// CHECK: step 0 op 'builtin.module' before all regions // CHECK: step 0 op 'builtin.module' before all regions
// CHECK: step 1 op 'builtin.func' before all regions // CHECK: step 1 op 'func.func' before all regions
// CHECK: step 2 op 'arith.constant' before all regions // CHECK: step 2 op 'arith.constant' before all regions
// CHECK: step 3 op 'arith.constant' before all regions // CHECK: step 3 op 'arith.constant' before all regions
// CHECK: step 4 op 'arith.constant' before all regions // CHECK: step 4 op 'arith.constant' before all regions
// CHECK: step 5 op 'scf.for' before all regions // CHECK: step 5 op 'scf.for' before all regions
// CHECK: step 6 op 'use0' before all regions // CHECK: step 6 op 'use0' before all regions
// CHECK: step 7 op 'scf.if' before all regions // CHECK: step 7 op 'scf.if' before all regions
// CHECK: step 8 op 'use1' before all regions // CHECK: step 8 op 'use1' before all regions
// CHECK: step 9 op 'scf.yield' before all regions // CHECK: step 9 op 'scf.yield' before all regions
// CHECK: step 10 op 'scf.if' before region #1 // CHECK: step 10 op 'scf.if' before region #1
// CHECK: step 11 op 'use2' before all regions // CHECK: step 11 op 'use2' before all regions
// CHECK: step 12 op 'scf.yield' before all regions // CHECK: step 12 op 'scf.yield' before all regions
// CHECK: step 13 op 'scf.if' after all regions // CHECK: step 13 op 'scf.if' after all regions
// CHECK: step 14 op 'use3' before all regions // CHECK: step 14 op 'use3' before all regions
// CHECK: step 15 op 'scf.yield' before all regions // CHECK: step 15 op 'scf.yield' before all regions
// CHECK: step 16 op 'scf.for' after all regions // CHECK: step 16 op 'scf.for' after all regions
// CHECK: step 17 op 'func.return' before all regions // CHECK: step 17 op 'func.return' before all regions
// CHECK: step 18 op 'builtin.func' after all regions // CHECK: step 18 op 'func.func' after all regions
// CHECK: step 19 op 'builtin.module' after all regions // CHECK: step 19 op 'builtin.module' after all regions
// ----- // -----
// Test the specific operation type visitor. // Test the specific operation type visitor.
func @correct_number_of_regions() { func @correct_number_of_regions() {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
Show All 15 Lines

mlir/test/IR/invalid-func-op.mlir

// RUN: mlir-opt %s -split-input-file -verify-diagnostics // RUN: mlir-opt %s -split-input-file -verify-diagnostics
// ----- // -----
func @func_op() { func @func_op() {
// expected-error@+1 {{expected valid '@'-identifier for symbol name}} // expected-error@+1 {{expected valid '@'-identifier for symbol name}}
builtin.func missingsigil() -> (i1, index, f32) func.func missingsigil() -> (i1, index, f32)
return return
} }
// ----- // -----
func @func_op() { func @func_op() {
// expected-error@+1 {{expected type instead of SSA identifier}} // expected-error@+1 {{expected type instead of SSA identifier}}
builtin.func @mixed_named_arguments(f32, %a : i32) { func.func @mixed_named_arguments(f32, %a : i32) {
return return
} }
return return
} }
// ----- // -----
func @func_op() { func @func_op() {
// expected-error@+1 {{expected SSA identifier}} // expected-error@+1 {{expected SSA identifier}}
builtin.func @mixed_named_arguments(%a : i32, f32) -> () { func.func @mixed_named_arguments(%a : i32, f32) -> () {
return return
} }
return return
} }
// ----- // -----
func @func_op() { func @func_op() {
// expected-error@+1 {{entry block must have 1 arguments to match function signature}} // expected-error@+1 {{entry block must have 1 arguments to match function signature}}
builtin.func @mixed_named_arguments(f32) { func.func @mixed_named_arguments(f32) {
^entry: ^entry:
return return
} }
return return
} }
// ----- // -----
func @func_op() { func @func_op() {
// expected-error@+1 {{type of entry block argument #0('i32') must match the type of the corresponding argument in function signature('f32')}} // expected-error@+1 {{type of entry block argument #0('i32') must match the type of the corresponding argument in function signature('f32')}}
builtin.func @mixed_named_arguments(f32) { func.func @mixed_named_arguments(f32) {
^entry(%arg : i32): ^entry(%arg : i32):
return return
} }
return return
} }
// ----- // -----
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

mlir/test/IR/invalid-ops.mlir

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines^bb0(%cond : tensor<12xi1>, %t : tensor<42xi32>, %f : tensor<42xi32>):
// expected-error@+1 {{all non-scalar operands/results must have the same shape and base type}} // expected-error@+1 {{all non-scalar operands/results must have the same shape and base type}}
%r = "arith.select"(%cond, %t, %f) : (tensor<12xi1>, tensor<42xi32>, tensor<42xi32>) -> tensor<42xi32> %r = "arith.select"(%cond, %t, %f) : (tensor<12xi1>, tensor<42xi32>, tensor<42xi32>) -> tensor<42xi32>
} }
// ----- // -----
func @return_not_in_function() { func @return_not_in_function() {
"foo.region"() ({ "foo.region"() ({
// expected-error@+1 {{'func.return' op expects parent op 'builtin.func'}} // expected-error@+1 {{'func.return' op expects parent op 'func.func'}}
return return
}): () -> () }): () -> ()
return return
} }
// ----- // -----
func @invalid_splat(%v : f32) { // expected-note {{prior use here}} func @invalid_splat(%v : f32) { // expected-note {{prior use here}}
vector.splat %v : vector<8xf64> vector.splat %v : vector<8xf64>
// expected-error@-1 {{expects different type than prior uses}} // expected-error@-1 {{expects different type than prior uses}}
return return
} }

mlir/test/IR/invalid.mlir

Show First 20 Lines • Show All 536 Lines • ▼ Show 20 Linesfunc @return_type_mismatch() -> i32 {
%0 = "foo"() : ()->f32 %0 = "foo"() : ()->f32
return %0 : f32 // expected-error {{type of return operand 0 ('f32') doesn't match function result type ('i32') in function @return_type_mismatch}} return %0 : f32 // expected-error {{type of return operand 0 ('f32') doesn't match function result type ('i32') in function @return_type_mismatch}}
} }
// ----- // -----
func @return_inside_loop() { func @return_inside_loop() {
affine.for %i = 1 to 100 { affine.for %i = 1 to 100 {
// expected-error@+1 {{'func.return' op expects parent op 'builtin.func'}} // expected-error@+1 {{'func.return' op expects parent op 'func.func'}}
return return
} }
return return
} }
// ----- // -----
// expected-error@+1 {{expected three consecutive dots for an ellipsis}} // expected-error@+1 {{expected three consecutive dots for an ellipsis}}
▲ Show 20 Lines • Show All 1,092 Lines • Show Last 20 Lines

mlir/test/IR/print-ir-invalid.mlir

// # RUN: mlir-opt -test-print-invalid %s | FileCheck %s // # RUN: mlir-opt -test-print-invalid %s | FileCheck %s
// # RUN: mlir-opt -test-print-invalid %s --mlir-print-assume-verified | FileCheck %s --check-prefix=ASSUME-VERIFIED // # RUN: mlir-opt -test-print-invalid %s --mlir-print-assume-verified | FileCheck %s --check-prefix=ASSUME-VERIFIED
// The pass creates some ops and prints them to stdout, the input is just an // The pass creates some ops and prints them to stdout, the input is just an
// empty module. // empty module.
module {} module {}
// The operation is invalid because the body does not have a terminator, print // The operation is invalid because the body does not have a terminator, print
// the generic form. // the generic form.
// CHECK: Invalid operation: // CHECK: Invalid operation:
// CHECK-NEXT: "builtin.func"() ({ // CHECK-NEXT: "func.func"() ({
// CHECK-NEXT: ^bb0: // CHECK-NEXT: ^bb0:
// CHECK-NEXT: }) // CHECK-NEXT: })
// CHECK-SAME: sym_name = "test" // CHECK-SAME: sym_name = "test"
// The operation is valid because the body has a terminator, print the custom // The operation is valid because the body has a terminator, print the custom
// form. // form.
// CHECK: Valid operation: // CHECK: Valid operation:
// CHECK-NEXT: func @test() { // CHECK-NEXT: func @test() {
Show All 14 Lines

mlir/test/IR/test-matchers.mlir

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

mlir/test/IR/traits.mlir

Show First 20 Lines • Show All 569 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 @illegalInsideDominanceFreeScope() -> () { func @illegalInsideDominanceFreeScope() -> () {
test.graph_region { test.graph_region {
builtin.func @test() -> i1 { func.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)
// expected-note @+1 {{operand defined here}} // expected-note @+1 {{operand defined here}}
%1 = "baz"(%2#0) : (i1) -> (i64) %1 = "baz"(%2#0) : (i1) -> (i64)
return %2#1 : i1 return %2#1 : i1
} }
"terminator"() : () -> () "terminator"() : () -> ()
} }
return return
} }
// ----- // -----
// 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 { func.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)
cf.br ^bb4 cf.br ^bb4
^bb2: ^bb2:
cf.br ^bb2 cf.br ^bb2
^bb4: ^bb4:
%1 = "foo"() : ()->i64 // expected-note {{operand defined here}} %1 = "foo"() : ()->i64 // expected-note {{operand defined here}}
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

mlir/test/IR/visitors.mlir

Show All 17 Lines scf.for %i = %c1 to %c10 step %c1 {
} }
"use3"(%i) : (index) -> () "use3"(%i) : (index) -> ()
} }
return return
} }
// CHECK-LABEL: Op pre-order visit // CHECK-LABEL: Op pre-order visit
// CHECK: Visiting op 'builtin.module' // CHECK: Visiting op 'builtin.module'
// CHECK: Visiting op 'builtin.func' // CHECK: Visiting op 'func.func'
// CHECK: Visiting op 'scf.for' // CHECK: Visiting op 'scf.for'
// CHECK: Visiting op 'use0' // CHECK: Visiting op 'use0'
// CHECK: Visiting op 'scf.if' // CHECK: Visiting op 'scf.if'
// CHECK: Visiting op 'use1' // CHECK: Visiting op 'use1'
// CHECK: Visiting op 'use2' // CHECK: Visiting op 'use2'
// CHECK: Visiting op 'use3' // CHECK: Visiting op 'use3'
// CHECK: Visiting op 'func.return' // CHECK: Visiting op 'func.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 'func.func'
// CHECK: Visiting block ^bb0 from region 0 from operation 'scf.for' // CHECK: Visiting block ^bb0 from region 0 from operation 'scf.for'
// CHECK: Visiting block ^bb0 from region 0 from operation 'scf.if' // CHECK: Visiting block ^bb0 from region 0 from operation 'scf.if'
// CHECK: Visiting block ^bb0 from region 1 from operation 'scf.if' // CHECK: Visiting block ^bb0 from region 1 from operation 'scf.if'
// 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 'func.func'
// CHECK: Visiting region 0 from operation 'scf.for' // CHECK: Visiting region 0 from operation 'scf.for'
// CHECK: Visiting region 0 from operation 'scf.if' // CHECK: Visiting region 0 from operation 'scf.if'
// CHECK: Visiting region 1 from operation 'scf.if' // CHECK: Visiting region 1 from operation 'scf.if'
// CHECK-LABEL: Op post-order visits // CHECK-LABEL: Op post-order visits
// CHECK: Visiting op 'use0' // CHECK: Visiting op 'use0'
// CHECK: Visiting op 'use1' // CHECK: Visiting op 'use1'
// CHECK: Visiting op 'use2' // CHECK: Visiting op 'use2'
// CHECK: Visiting op 'scf.if' // CHECK: Visiting op 'scf.if'
// CHECK: Visiting op 'use3' // CHECK: Visiting op 'use3'
// CHECK: Visiting op 'scf.for' // CHECK: Visiting op 'scf.for'
// CHECK: Visiting op 'func.return' // CHECK: Visiting op 'func.return'
// CHECK: Visiting op 'builtin.func' // CHECK: Visiting op 'func.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 'scf.if' // CHECK: Visiting block ^bb0 from region 0 from operation 'scf.if'
// CHECK: Visiting block ^bb0 from region 1 from operation 'scf.if' // CHECK: Visiting block ^bb0 from region 1 from operation 'scf.if'
// CHECK: Visiting block ^bb0 from region 0 from operation 'scf.for' // CHECK: Visiting block ^bb0 from region 0 from operation 'scf.for'
// CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.func' // CHECK: Visiting block ^bb0 from region 0 from operation 'func.func'
// CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.module' // CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.module'
// CHECK-LABEL: Region post-order visits // CHECK-LABEL: Region post-order visits
// CHECK: Visiting region 0 from operation 'scf.if' // CHECK: Visiting region 0 from operation 'scf.if'
// CHECK: Visiting region 1 from operation 'scf.if' // CHECK: Visiting region 1 from operation 'scf.if'
// CHECK: Visiting region 0 from operation 'scf.for' // CHECK: Visiting region 0 from operation 'scf.for'
// CHECK: Visiting region 0 from operation 'builtin.func' // CHECK: Visiting region 0 from operation 'func.func'
// CHECK: Visiting region 0 from operation 'builtin.module' // CHECK: Visiting region 0 from operation 'builtin.module'
// CHECK-LABEL: Op pre-order erasures // CHECK-LABEL: Op pre-order erasures
// CHECK: Erasing op 'scf.for' // CHECK: Erasing op 'scf.for'
// CHECK: Erasing op 'func.return' // CHECK: Erasing op 'func.return'
// CHECK-LABEL: Block pre-order erasures // CHECK-LABEL: Block pre-order erasures
// CHECK: Erasing block ^bb0 from region 0 from operation 'scf.for' // CHECK: Erasing block ^bb0 from region 0 from operation 'scf.for'
Show All 15 Lines
// CHECK-LABEL: Op post-order erasures (no skip) // CHECK-LABEL: Op post-order erasures (no skip)
// CHECK: Erasing op 'use0' // CHECK: Erasing op 'use0'
// CHECK: Erasing op 'use1' // CHECK: Erasing op 'use1'
// CHECK: Erasing op 'use2' // CHECK: Erasing op 'use2'
// CHECK: Erasing op 'scf.if' // CHECK: Erasing op 'scf.if'
// CHECK: Erasing op 'use3' // CHECK: Erasing op 'use3'
// CHECK: Erasing op 'scf.for' // CHECK: Erasing op 'scf.for'
// CHECK: Erasing op 'func.return' // CHECK: Erasing op 'func.return'
// CHECK: Erasing op 'builtin.func' // CHECK: Erasing op 'func.func'
// CHECK: Erasing op 'builtin.module' // CHECK: Erasing op 'builtin.module'
// 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 'scf.if' // CHECK: Erasing block ^bb0 from region 0 from operation 'scf.if'
// CHECK: Erasing block ^bb0 from region 1 from operation 'scf.if' // CHECK: Erasing block ^bb0 from region 1 from operation 'scf.if'
// CHECK: Erasing block ^bb0 from region 0 from operation 'scf.for' // CHECK: Erasing block ^bb0 from region 0 from operation 'scf.for'
// CHECK: Erasing block ^bb0 from region 0 from operation 'builtin.func' // CHECK: Erasing block ^bb0 from region 0 from operation 'func.func'
// 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"() : () -> ()
cf.br ^bb2 cf.br ^bb2
^bb1: ^bb1:
"op1"() : () -> () "op1"() : () -> ()
cf.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 'func.func'
// CHECK: Visiting op 'regionOp0' // CHECK: Visiting op 'regionOp0'
// CHECK: Visiting op 'op0' // CHECK: Visiting op 'op0'
// CHECK: Visiting op 'cf.br' // CHECK: Visiting op 'cf.br'
// CHECK: Visiting op 'op1' // CHECK: Visiting op 'op1'
// CHECK: Visiting op 'cf.br' // CHECK: Visiting op 'cf.br'
// CHECK: Visiting op 'op2' // CHECK: Visiting op 'op2'
// CHECK: Visiting op 'func.return' // CHECK: Visiting op 'func.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 'func.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 'func.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 'cf.br' // CHECK: Visiting op 'cf.br'
// CHECK: Visiting op 'op1' // CHECK: Visiting op 'op1'
// CHECK: Visiting op 'cf.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 'func.return' // CHECK: Visiting op 'func.return'
// CHECK: Visiting op 'builtin.func' // CHECK: Visiting op 'func.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'
// 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: Visiting block ^bb0 from region 0 from operation 'builtin.func' // CHECK: Visiting block ^bb0 from region 0 from operation 'func.func'
// CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.module' // CHECK: Visiting block ^bb0 from region 0 from operation 'builtin.module'
// CHECK-LABEL: Region post-order visits // CHECK-LABEL: Region post-order visits
// CHECK: Visiting region 0 from operation 'regionOp0' // CHECK: Visiting region 0 from operation 'regionOp0'
// CHECK: Visiting region 0 from operation 'builtin.func' // CHECK: Visiting region 0 from operation 'func.func'
// CHECK: Visiting region 0 from operation 'builtin.module' // CHECK: Visiting region 0 from operation 'builtin.module'
// CHECK-LABEL: Op pre-order erasures (skip) // CHECK-LABEL: Op pre-order erasures (skip)
// CHECK: Erasing op 'regionOp0' // CHECK: Erasing op 'regionOp0'
// CHECK: Erasing op 'func.return' // CHECK: Erasing op 'func.return'
// 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'
Show All 22 Lines
// CHECK: Erasing op 'op2' // CHECK: Erasing op 'op2'
// CHECK: Erasing op 'regionOp0' // CHECK: Erasing op 'regionOp0'
// CHECK: Erasing op 'func.return' // CHECK: Erasing op 'func.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 'func.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/IR/wrapping_op.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s | FileCheck %s
// RUN: mlir-opt -allow-unregistered-dialect -mlir-print-op-generic -mlir-print-debuginfo -mlir-print-local-scope %s | FileCheck %s --check-prefix=CHECK-GENERIC // RUN: mlir-opt -allow-unregistered-dialect -mlir-print-op-generic -mlir-print-debuginfo -mlir-print-local-scope %s | FileCheck %s --check-prefix=CHECK-GENERIC
// CHECK-LABEL: func @wrapping_op // CHECK-LABEL: func @wrapping_op
// CHECK-GENERIC: "builtin.func" // CHECK-GENERIC: "func.func"
func @wrapping_op(%arg0 : i32, %arg1 : f32) -> (i3, i2, i1) { func @wrapping_op(%arg0 : i32, %arg1 : f32) -> (i3, i2, i1) {
// CHECK: %0:3 = test.wrapping_region wraps "some.op"(%arg1, %arg0) {test.attr = "attr"} : (f32, i32) -> (i1, i2, i3) // CHECK: %0:3 = test.wrapping_region wraps "some.op"(%arg1, %arg0) {test.attr = "attr"} : (f32, i32) -> (i1, i2, i3)
// CHECK-GENERIC: "test.wrapping_region"() ({ // CHECK-GENERIC: "test.wrapping_region"() ({
// CHECK-GENERIC: %[[NESTED_RES:.*]]:3 = "some.op"(%arg1, %arg0) {test.attr = "attr"} : (f32, i32) -> (i1, i2, i3) loc("some_NameLoc") // CHECK-GENERIC: %[[NESTED_RES:.*]]:3 = "some.op"(%arg1, %arg0) {test.attr = "attr"} : (f32, i32) -> (i1, i2, i3) loc("some_NameLoc")
// CHECK-GENERIC: "test.return"(%[[NESTED_RES]]#0, %[[NESTED_RES]]#1, %[[NESTED_RES]]#2) : (i1, i2, i3) -> () loc("some_NameLoc") // CHECK-GENERIC: "test.return"(%[[NESTED_RES]]#0, %[[NESTED_RES]]#1, %[[NESTED_RES]]#2) : (i1, i2, i3) -> () loc("some_NameLoc")
// CHECK-GENERIC: }) : () -> (i1, i2, i3) loc("some_NameLoc") // CHECK-GENERIC: }) : () -> (i1, i2, i3) loc("some_NameLoc")
%res:3 = test.wrapping_region wraps "some.op"(%arg1, %arg0) { test.attr = "attr" } : (f32, i32) -> (i1, i2, i3) loc("some_NameLoc") %res:3 = test.wrapping_region wraps "some.op"(%arg1, %arg0) { test.attr = "attr" } : (f32, i32) -> (i1, i2, i3) loc("some_NameLoc")
return %res#2, %res#1, %res#0 : i3, i2, i1 return %res#2, %res#1, %res#0 : i3, i2, i1
} }
// CHECK-GENERIC: sym_name = "wrapping_op" // CHECK-GENERIC: sym_name = "wrapping_op"

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 -pass-pipeline="builtin.func(canonicalize,convert-vector-to-scf,lower-affine,convert-linalg-to-loops)" | \ // RUN: mlir-opt -pass-pipeline="func.func(canonicalize,convert-vector-to-scf,lower-affine,convert-linalg-to-loops)" | \
// RUN: mlir-opt -pass-pipeline="builtin.func(canonicalize,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt -pass-pipeline="func.func(canonicalize,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \
// 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/test-comprehensive-bufferize.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.func(canonicalize,cse),linalg-comprehensive-module-bufferize" |\ // RUN: mlir-opt %s -pass-pipeline="func.func(canonicalize,cse),linalg-comprehensive-module-bufferize" |\
// RUN: mlir-opt -pass-pipeline="builtin.func(buffer-deallocation,convert-vector-to-scf,lower-affine,convert-linalg-to-loops)" |\ // RUN: mlir-opt -pass-pipeline="func.func(buffer-deallocation,convert-vector-to-scf,lower-affine,convert-linalg-to-loops)" |\
// RUN: mlir-opt -pass-pipeline="builtin.func(canonicalize,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt -pass-pipeline="func.func(canonicalize,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_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/SparseTensor/python/test_SDDMM.py

# RUN: SUPPORT_LIB=%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \ # RUN: SUPPORT_LIB=%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
# RUN: %PYTHON %s | FileCheck %s # RUN: %PYTHON %s | FileCheck %s
import ctypes import ctypes
import numpy as np import numpy as np
import os import os
import sys import sys
from mlir import ir from mlir import ir
from mlir import runtime as rt from mlir import runtime as rt
from mlir import execution_engine from mlir import execution_engine
from mlir.dialects import sparse_tensor as st from mlir.dialects import sparse_tensor as st
from mlir.dialects import builtin from mlir.dialects import builtin
from mlir.dialects import func
from mlir.dialects.linalg.opdsl import lang as dsl from mlir.dialects.linalg.opdsl import lang as dsl
_SCRIPT_PATH = os.path.dirname(os.path.abspath(__file__)) _SCRIPT_PATH = os.path.dirname(os.path.abspath(__file__))
sys.path.append(_SCRIPT_PATH) sys.path.append(_SCRIPT_PATH)
from tools import sparse_compiler from tools import sparse_compiler
@dsl.linalg_structured_op @dsl.linalg_structured_op
def sddmm_dsl( def sddmm_dsl(
Show All 16 Linesdef build_SDDMM(attr: st.EncodingAttr):
f64 = ir.F64Type.get() f64 = ir.F64Type.get()
a = ir.RankedTensorType.get([8, 8], f64) a = ir.RankedTensorType.get([8, 8], f64)
b = ir.RankedTensorType.get([8, 8], f64) b = ir.RankedTensorType.get([8, 8], f64)
c = ir.RankedTensorType.get([8, 8], f64) c = ir.RankedTensorType.get([8, 8], f64)
s = ir.RankedTensorType.get([8, 8], f64, attr) s = ir.RankedTensorType.get([8, 8], f64, attr)
arguments = [a, b, s, c] arguments = [a, b, s, c]
with ir.InsertionPoint(module.body): with ir.InsertionPoint(module.body):
@builtin.FuncOp.from_py_func(*arguments) @func.FuncOp.from_py_func(*arguments)
def sddmm(*args): def sddmm(*args):
return sddmm_dsl(args[0], args[1], args[2], outs=[args[3]]) return sddmm_dsl(args[0], args[1], args[2], outs=[args[3]])
return module return module
def boilerplate(attr: st.EncodingAttr): def boilerplate(attr: st.EncodingAttr):
"""Returns boilerplate code for main driver.""" """Returns boilerplate code for main driver."""
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/python/test_SpMM.py

# RUN: SUPPORT_LIB=%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \ # RUN: SUPPORT_LIB=%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
# RUN: %PYTHON %s | FileCheck %s # RUN: %PYTHON %s | FileCheck %s
import ctypes import ctypes
import numpy as np import numpy as np
import os import os
import sys import sys
from mlir import ir from mlir import ir
from mlir import runtime as rt from mlir import runtime as rt
from mlir import execution_engine from mlir import execution_engine
from mlir.dialects import sparse_tensor as st from mlir.dialects import sparse_tensor as st
from mlir.dialects import builtin from mlir.dialects import builtin
from mlir.dialects import func
from mlir.dialects.linalg.opdsl import lang as dsl from mlir.dialects.linalg.opdsl import lang as dsl
_SCRIPT_PATH = os.path.dirname(os.path.abspath(__file__)) _SCRIPT_PATH = os.path.dirname(os.path.abspath(__file__))
sys.path.append(_SCRIPT_PATH) sys.path.append(_SCRIPT_PATH)
from tools import sparse_compiler from tools import sparse_compiler
@dsl.linalg_structured_op @dsl.linalg_structured_op
def matmul_dsl( def matmul_dsl(
Show All 13 Linesdef build_SpMM(attr: st.EncodingAttr):
module = ir.Module.create() module = ir.Module.create()
f64 = ir.F64Type.get() f64 = ir.F64Type.get()
a = ir.RankedTensorType.get([3, 4], f64, attr) a = ir.RankedTensorType.get([3, 4], f64, attr)
b = ir.RankedTensorType.get([4, 2], f64) b = ir.RankedTensorType.get([4, 2], f64)
c = ir.RankedTensorType.get([3, 2], f64) c = ir.RankedTensorType.get([3, 2], f64)
arguments = [a, b, c] arguments = [a, b, c]
with ir.InsertionPoint(module.body): with ir.InsertionPoint(module.body):
@builtin.FuncOp.from_py_func(*arguments) @func.FuncOp.from_py_func(*arguments)
def spMxM(*args): def spMxM(*args):
return matmul_dsl(args[0], args[1], outs=[args[2]]) return matmul_dsl(args[0], args[1], outs=[args[2]])
return module return module
def boilerplate(attr: st.EncodingAttr): def boilerplate(attr: st.EncodingAttr):
"""Returns boilerplate main method. """Returns boilerplate main method.
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/python/test_stress.py

Show First 20 Lines • Show All 104 Lines • ▼ Show 20 Lines def build(self, types: List[ir.Type]):
assert self._module is None, 'StressTest: must not call build() repeatedly' assert self._module is None, 'StressTest: must not call build() repeatedly'
self._module = ir.Module.create() self._module = ir.Module.create()
with ir.InsertionPoint(self._module.body): with ir.InsertionPoint(self._module.body):
tp0 = types.pop(0) tp0 = types.pop(0)
self._roundtripTp = tp0 self._roundtripTp = tp0
# TODO: assert dense? assert element type is recognised by the TypeConverter? # TODO: assert dense? assert element type is recognised by the TypeConverter?
types.append(tp0) types.append(tp0)
funcTp = ir.FunctionType.get(inputs=[tp0], results=[tp0]) funcTp = ir.FunctionType.get(inputs=[tp0], results=[tp0])
funcOp = builtin.FuncOp(name='main', type=funcTp) funcOp = func.FuncOp(name='main', type=funcTp)
funcOp.attributes['llvm.emit_c_interface'] = ir.UnitAttr.get() funcOp.attributes['llvm.emit_c_interface'] = ir.UnitAttr.get()
with ir.InsertionPoint(funcOp.add_entry_block()): with ir.InsertionPoint(funcOp.add_entry_block()):
arg0 = funcOp.entry_block.arguments[0] arg0 = funcOp.entry_block.arguments[0]
self._assertEqualsRoundtripTp(arg0.type) self._assertEqualsRoundtripTp(arg0.type)
v = st.ConvertOp(types.pop(0), arg0) v = st.ConvertOp(types.pop(0), arg0)
for tp in types: for tp in types:
w = st.ConvertOp(tp, v) w = st.ConvertOp(tp, v)
# Release intermediate tensors before they fall out of scope. # Release intermediate tensors before they fall out of scope.
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 664 Lines • ▼ Show 20 Lines def _emit_assignment(
input_accesses: List["Access"], input_accesses: List["Access"],
) -> None: ) -> None:
"""Emits an MLIR function for assigning the expression to a tensor.""" """Emits an MLIR function for assigning the expression to a tensor."""
input_types = [a.tensor.mlir_tensor_type() for a in input_accesses] input_types = [a.tensor.mlir_tensor_type() for a in input_accesses]
# Build the kernel for the operations. # Build the kernel for the operations.
with ir.InsertionPoint(module.body): with ir.InsertionPoint(module.body):
@builtin.FuncOp.from_py_func(*input_types, name=_ENTRY_NAME) @func.FuncOp.from_py_func(*input_types, name=_ENTRY_NAME)
def linalg_funcop(*args): def linalg_funcop(*args):
# Set up the mapping from the Access nodes to their MLIR values. # Set up the mapping from the Access nodes to their MLIR values.
for e, mlir in zip(input_accesses, args): for e, mlir in zip(input_accesses, args):
expr_to_info[e].mlir_value = mlir expr_to_info[e].mlir_value = mlir
# Emit structured ops in the linalg dialect to implement the assignment. # Emit structured ops in the linalg dialect to implement the assignment.
for structop_root in self._identify_structured_ops( for structop_root in self._identify_structured_ops(
expr_to_info, dst, dst_indices): expr_to_info, dst, dst_indices):
▲ Show 20 Lines • Show All 1,491 Lines • Show Last 20 Lines

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

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

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

// RUN: mlir-opt %s -pass-pipeline="builtin.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf{lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf{full-unroll=true lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf{lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf{full-unroll=true lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf{lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf{full-unroll=true lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true lower-permutation-maps=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_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-vector-distribute.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.func(test-vector-to-forloop,convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \ // RUN: mlir-opt %s -pass-pipeline="func.func(test-vector-to-forloop,convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_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 -pass-pipeline="builtin.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e main \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | 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 -pass-pipeline="builtin.func(test-vector-to-forloop)" | FileCheck %s -check-prefix=TRANSFORM // RUN: mlir-opt %s -pass-pipeline="func.func(test-vector-to-forloop)" | FileCheck %s -check-prefix=TRANSFORM
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(memref<*xf32>)
func @alloc_1d_filled_inc_f32(%arg0: index, %arg1: f32) -> memref<?xf32> { func @alloc_1d_filled_inc_f32(%arg0: index, %arg1: f32) -> memref<?xf32> {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%0 = memref.alloc(%arg0) : memref<?xf32> %0 = memref.alloc(%arg0) : memref<?xf32>
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

mlir/test/Pass/dynamic-pipeline.mlir

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

mlir/test/Pass/interface-pass.mlir

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

mlir/test/Pass/invalid-parent.mlir

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

mlir/test/Pass/ir-printing.mlir

// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,canonicalize)' -print-ir-before=cse -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE %s // RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -print-ir-before=cse -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE %s
// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,canonicalize)' -print-ir-before-all -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_ALL %s // RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -print-ir-before-all -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_ALL %s
// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,canonicalize)' -print-ir-after=cse -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER %s // RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -print-ir-after=cse -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER %s
// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,canonicalize)' -print-ir-after-all -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL %s // RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -print-ir-after-all -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL %s
// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,canonicalize)' -print-ir-before=cse -print-ir-module-scope -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_MODULE %s // RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -print-ir-before=cse -print-ir-module-scope -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_MODULE %s
// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,cse)' -print-ir-after-all -print-ir-after-change -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL_CHANGE %s // RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,cse)' -print-ir-after-all -print-ir-after-change -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL_CHANGE %s
// RUN: not mlir-opt %s -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,test-pass-failure)' -print-ir-after-failure -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_FAILURE %s // RUN: not mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,test-pass-failure)' -print-ir-after-failure -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_FAILURE %s
func @foo() { func @foo() {
%0 = arith.constant 0 : i32 %0 = arith.constant 0 : i32
return return
} }
func @bar() { func @bar() {
return return
Show All 28 Lines
// AFTER_ALL-NEXT: func @foo() // AFTER_ALL-NEXT: func @foo()
// AFTER_ALL: // -----// IR Dump After{{.*}}Canonicalizer //----- // // AFTER_ALL: // -----// IR Dump After{{.*}}Canonicalizer //----- //
// AFTER_ALL-NEXT: func @foo() // AFTER_ALL-NEXT: func @foo()
// AFTER_ALL: // -----// IR Dump After{{.*}}CSE //----- // // AFTER_ALL: // -----// IR Dump After{{.*}}CSE //----- //
// AFTER_ALL-NEXT: func @bar() // AFTER_ALL-NEXT: func @bar()
// AFTER_ALL: // -----// IR Dump After{{.*}}Canonicalizer //----- // // AFTER_ALL: // -----// IR Dump After{{.*}}Canonicalizer //----- //
// AFTER_ALL-NEXT: func @bar() // AFTER_ALL-NEXT: func @bar()
// BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSE ('builtin.func' operation: @foo) //----- // // BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSE ('func.func' operation: @foo) //----- //
// BEFORE_MODULE: func @foo() // BEFORE_MODULE: func @foo()
// BEFORE_MODULE: func @bar() // BEFORE_MODULE: func @bar()
// BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSE ('builtin.func' operation: @bar) //----- // // BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSE ('func.func' operation: @bar) //----- //
// BEFORE_MODULE: func @foo() // BEFORE_MODULE: func @foo()
// BEFORE_MODULE: func @bar() // BEFORE_MODULE: func @bar()
// AFTER_ALL_CHANGE: // -----// IR Dump After{{.*}}CSE //----- // // AFTER_ALL_CHANGE: // -----// IR Dump After{{.*}}CSE //----- //
// AFTER_ALL_CHANGE-NEXT: func @foo() // AFTER_ALL_CHANGE-NEXT: func @foo()
// AFTER_ALL_CHANGE-NOT: // -----// IR Dump After{{.*}}CSE //----- // // AFTER_ALL_CHANGE-NOT: // -----// IR Dump After{{.*}}CSE //----- //
// We expect that only 'foo' changed during CSE, and the second run of CSE did // We expect that only 'foo' changed during CSE, and the second run of CSE did
// nothing. // nothing.
// AFTER_FAILURE-NOT: // -----// IR Dump After{{.*}}CSE // AFTER_FAILURE-NOT: // -----// IR Dump After{{.*}}CSE
// AFTER_FAILURE: // -----// IR Dump After{{.*}}TestFailurePass Failed //----- // // AFTER_FAILURE: // -----// IR Dump After{{.*}}TestFailurePass Failed //----- //

mlir/test/Pass/pass-timing.mlir

// RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='builtin.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=list 2>&1 | FileCheck -check-prefix=LIST %s // RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='func.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=list 2>&1 | FileCheck -check-prefix=LIST %s
// RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='builtin.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=PIPELINE %s // RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=true -pass-pipeline='func.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=PIPELINE %s
// RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='builtin.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=list 2>&1 | FileCheck -check-prefix=MT_LIST %s // RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='func.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=list 2>&1 | FileCheck -check-prefix=MT_LIST %s
// RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='builtin.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=MT_PIPELINE %s // RUN: mlir-opt %s -mlir-disable-threading=false -verify-each=true -pass-pipeline='func.func(cse,canonicalize,cse)' -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=MT_PIPELINE %s
// RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=false -test-pm-nested-pipeline -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=NESTED_PIPELINE %s // RUN: mlir-opt %s -mlir-disable-threading=true -verify-each=false -test-pm-nested-pipeline -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck -check-prefix=NESTED_PIPELINE %s
// LIST: Execution time report // LIST: Execution time report
// LIST: Total Execution Time: // LIST: Total Execution Time:
// LIST: Name // LIST: Name
// LIST-DAG: Canonicalizer // LIST-DAG: Canonicalizer
// LIST-DAG: CSE // LIST-DAG: CSE
// LIST-DAG: DominanceInfo // LIST-DAG: DominanceInfo
// LIST: Total // LIST: Total
// PIPELINE: Execution time report // PIPELINE: Execution time report
// PIPELINE: Total Execution Time: // PIPELINE: Total Execution Time:
// PIPELINE: Name // PIPELINE: Name
// PIPELINE-NEXT: Parser // PIPELINE-NEXT: Parser
// PIPELINE-NEXT: 'builtin.func' Pipeline // PIPELINE-NEXT: 'func.func' Pipeline
// PIPELINE-NEXT: CSE // PIPELINE-NEXT: CSE
// PIPELINE-NEXT: (A) DominanceInfo // PIPELINE-NEXT: (A) DominanceInfo
// PIPELINE-NEXT: Canonicalizer // PIPELINE-NEXT: Canonicalizer
// PIPELINE-NEXT: CSE // PIPELINE-NEXT: CSE
// PIPELINE-NEXT: (A) DominanceInfo // PIPELINE-NEXT: (A) DominanceInfo
// PIPELINE-NEXT: Output // PIPELINE-NEXT: Output
// PIPELINE-NEXT: Rest // PIPELINE-NEXT: Rest
// PIPELINE-NEXT: Total // PIPELINE-NEXT: Total
// MT_LIST: Execution time report // MT_LIST: Execution time report
// MT_LIST: Total Execution Time: // MT_LIST: Total Execution Time:
// MT_LIST: Name // MT_LIST: Name
// MT_LIST-DAG: Canonicalizer // MT_LIST-DAG: Canonicalizer
// MT_LIST-DAG: CSE // MT_LIST-DAG: CSE
// MT_LIST-DAG: DominanceInfo // MT_LIST-DAG: DominanceInfo
// MT_LIST: Total // MT_LIST: Total
// MT_PIPELINE: Execution time report // MT_PIPELINE: Execution time report
// MT_PIPELINE: Total Execution Time: // MT_PIPELINE: Total Execution Time:
// MT_PIPELINE: Name // MT_PIPELINE: Name
// MT_PIPELINE-NEXT: Parser // MT_PIPELINE-NEXT: Parser
// MT_PIPELINE-NEXT: 'builtin.func' Pipeline // MT_PIPELINE-NEXT: 'func.func' Pipeline
// MT_PIPELINE-NEXT: CSE // MT_PIPELINE-NEXT: CSE
// MT_PIPELINE-NEXT: (A) DominanceInfo // MT_PIPELINE-NEXT: (A) DominanceInfo
// MT_PIPELINE-NEXT: Canonicalizer // MT_PIPELINE-NEXT: Canonicalizer
// MT_PIPELINE-NEXT: CSE // MT_PIPELINE-NEXT: CSE
// MT_PIPELINE-NEXT: (A) DominanceInfo // MT_PIPELINE-NEXT: (A) DominanceInfo
// MT_PIPELINE-NEXT: Output // MT_PIPELINE-NEXT: Output
// MT_PIPELINE-NEXT: Rest // MT_PIPELINE-NEXT: Rest
// MT_PIPELINE-NEXT: Total // MT_PIPELINE-NEXT: Total
// NESTED_PIPELINE: Execution time report // NESTED_PIPELINE: Execution time report
// NESTED_PIPELINE: Total Execution Time: // NESTED_PIPELINE: Total Execution Time:
// NESTED_PIPELINE: Name // NESTED_PIPELINE: Name
// NESTED_PIPELINE-NEXT: Parser // NESTED_PIPELINE-NEXT: Parser
// NESTED_PIPELINE-NEXT: Pipeline Collection : ['builtin.func', 'builtin.module'] // NESTED_PIPELINE-NEXT: Pipeline Collection : ['builtin.module', 'func.func']
// NESTED_PIPELINE-NEXT: 'builtin.func' Pipeline // NESTED_PIPELINE-NEXT: 'func.func' Pipeline
// NESTED_PIPELINE-NEXT: TestFunctionPass // NESTED_PIPELINE-NEXT: TestFunctionPass
// NESTED_PIPELINE-NEXT: 'builtin.module' Pipeline // NESTED_PIPELINE-NEXT: 'builtin.module' Pipeline
// NESTED_PIPELINE-NEXT: TestModulePass // NESTED_PIPELINE-NEXT: TestModulePass
// NESTED_PIPELINE-NEXT: 'builtin.func' Pipeline // NESTED_PIPELINE-NEXT: 'func.func' Pipeline
// NESTED_PIPELINE-NEXT: TestFunctionPass // NESTED_PIPELINE-NEXT: TestFunctionPass
// NESTED_PIPELINE-NEXT: Output // NESTED_PIPELINE-NEXT: Output
// NESTED_PIPELINE-NEXT: Rest // NESTED_PIPELINE-NEXT: Rest
// NESTED_PIPELINE-NEXT: Total // NESTED_PIPELINE-NEXT: Total
func @foo() { func @foo() {
return return
} }
Show All 22 Lines

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

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

mlir/test/Pass/pipeline-parsing.mlir

// RUN: mlir-opt %s -mlir-disable-threading -pass-pipeline='builtin.module(test-module-pass,builtin.func(test-function-pass)),builtin.func(test-function-pass)' -pass-pipeline="builtin.func(cse,canonicalize)" -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s // RUN: mlir-opt %s -mlir-disable-threading -pass-pipeline='builtin.module(test-module-pass,func.func(test-function-pass)),func.func(test-function-pass)' -pass-pipeline="func.func(cse,canonicalize)" -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s
// RUN: mlir-opt %s -mlir-disable-threading -test-textual-pm-nested-pipeline -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s --check-prefix=TEXTUAL_CHECK // RUN: mlir-opt %s -mlir-disable-threading -test-textual-pm-nested-pipeline -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s --check-prefix=TEXTUAL_CHECK
// RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_1 %s // RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_1 %s
// RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass))' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_2 %s // RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass))' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_2 %s
// RUN: not mlir-opt %s -pass-pipeline='builtin.module()(' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_3 %s // RUN: not mlir-opt %s -pass-pipeline='builtin.module()(' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_3 %s
// RUN: not mlir-opt %s -pass-pipeline=',' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_4 %s // RUN: not mlir-opt %s -pass-pipeline=',' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_4 %s
// RUN: not mlir-opt %s -pass-pipeline='builtin.func(test-module-pass)' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_5 %s // RUN: not mlir-opt %s -pass-pipeline='func.func(test-module-pass)' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_5 %s
// CHECK_ERROR_1: encountered unbalanced parentheses while parsing pipeline // CHECK_ERROR_1: encountered unbalanced parentheses while parsing pipeline
// CHECK_ERROR_2: encountered extra closing ')' creating unbalanced parentheses while parsing pipeline // CHECK_ERROR_2: encountered extra closing ')' creating unbalanced parentheses while parsing pipeline
// CHECK_ERROR_3: expected ',' after parsing pipeline // CHECK_ERROR_3: expected ',' after parsing pipeline
// CHECK_ERROR_4: does not refer to a registered pass or pass pipeline // CHECK_ERROR_4: does not refer to a registered pass or pass pipeline
// CHECK_ERROR_5: Can't add pass '{{.*}}TestModulePass' restricted to 'builtin.module' on a PassManager intended to run on 'builtin.func', did you intend to nest? // CHECK_ERROR_5: Can't add pass '{{.*}}TestModulePass' restricted to 'builtin.module' on a PassManager intended to run on 'func.func', did you intend to nest?
func @foo() { func @foo() {
return return
} }
module { module {
func @foo() { func @foo() {
return return
} }
} }
// CHECK: Pipeline Collection : ['builtin.func', 'builtin.module'] // CHECK: Pipeline Collection : ['builtin.module', 'func.func']
// CHECK-NEXT: 'builtin.func' Pipeline // CHECK-NEXT: 'func.func' Pipeline
// CHECK-NEXT: TestFunctionPass // CHECK-NEXT: TestFunctionPass
// CHECK-NEXT: CSE // CHECK-NEXT: CSE
// CHECK-NEXT: DominanceInfo // CHECK-NEXT: DominanceInfo
// CHECK-NEXT: Canonicalizer // CHECK-NEXT: Canonicalizer
// CHECK-NEXT: 'builtin.module' Pipeline // CHECK-NEXT: 'builtin.module' Pipeline
// CHECK-NEXT: TestModulePass // CHECK-NEXT: TestModulePass
// CHECK-NEXT: 'builtin.func' Pipeline // CHECK-NEXT: 'func.func' Pipeline
// CHECK-NEXT: TestFunctionPass // CHECK-NEXT: TestFunctionPass
// TEXTUAL_CHECK: Pipeline Collection : ['builtin.func', 'builtin.module'] // TEXTUAL_CHECK: Pipeline Collection : ['builtin.module', 'func.func']
// TEXTUAL_CHECK-NEXT: 'builtin.func' Pipeline // TEXTUAL_CHECK-NEXT: 'func.func' Pipeline
// TEXTUAL_CHECK-NEXT: TestFunctionPass // TEXTUAL_CHECK-NEXT: TestFunctionPass
// TEXTUAL_CHECK-NEXT: 'builtin.module' Pipeline // TEXTUAL_CHECK-NEXT: 'builtin.module' Pipeline
// TEXTUAL_CHECK-NEXT: TestModulePass // TEXTUAL_CHECK-NEXT: TestModulePass
// TEXTUAL_CHECK-NEXT: 'builtin.func' Pipeline // TEXTUAL_CHECK-NEXT: 'func.func' Pipeline
// TEXTUAL_CHECK-NEXT: TestFunctionPass // TEXTUAL_CHECK-NEXT: TestFunctionPass

mlir/test/Pass/pipeline-stats.mlir

// REQUIRES: asserts // REQUIRES: asserts
// RUN: mlir-opt %s -verify-each=true -pass-pipeline='builtin.func(test-stats-pass,test-stats-pass)' -pass-statistics -pass-statistics-display=list 2>&1 | FileCheck -check-prefix=LIST %s // RUN: mlir-opt %s -verify-each=true -pass-pipeline='func.func(test-stats-pass,test-stats-pass)' -pass-statistics -pass-statistics-display=list 2>&1 | FileCheck -check-prefix=LIST %s
// RUN: mlir-opt %s -verify-each=true -pass-pipeline='builtin.func(test-stats-pass,test-stats-pass)' -pass-statistics -pass-statistics-display=pipeline 2>&1 | FileCheck -check-prefix=PIPELINE %s // RUN: mlir-opt %s -verify-each=true -pass-pipeline='func.func(test-stats-pass,test-stats-pass)' -pass-statistics -pass-statistics-display=pipeline 2>&1 | FileCheck -check-prefix=PIPELINE %s
// LIST: Pass statistics report // LIST: Pass statistics report
// LIST: TestStatisticPass // LIST: TestStatisticPass
// LIST-NEXT: (S) {{0|8}} num-ops - Number of operations counted // LIST-NEXT: (S) {{0|8}} num-ops - Number of operations counted
// LIST-NOT: Verifier // LIST-NOT: Verifier
// PIPELINE: Pass statistics report // PIPELINE: Pass statistics report
// PIPELINE: 'builtin.func' Pipeline // PIPELINE: 'func.func' Pipeline
// PIPELINE-NEXT: TestStatisticPass // PIPELINE-NEXT: TestStatisticPass
// PIPELINE-NEXT: (S) {{0|4}} num-ops - Number of operations counted // PIPELINE-NEXT: (S) {{0|4}} num-ops - Number of operations counted
// PIPELINE-NEXT: TestStatisticPass // PIPELINE-NEXT: TestStatisticPass
// PIPELINE-NEXT: (S) {{0|4}} num-ops - Number of operations counted // PIPELINE-NEXT: (S) {{0|4}} num-ops - Number of operations counted
func @foo() { func @foo() {
return return
} }
func @bar() { func @bar() {
return return
} }

mlir/test/Pass/run-reproducer.mlir

// configuration: -mlir-disable-threading=true -pass-pipeline='builtin.func(cse,canonicalize)' -print-ir-before=cse // configuration: -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -print-ir-before=cse
// Test of the reproducer run option. The first line has to be the // Test of the reproducer run option. The first line has to be the
// configuration (matching what is produced by reproducer). // configuration (matching what is produced by reproducer).
// RUN: mlir-opt %s -run-reproducer 2>&1 | FileCheck -check-prefix=BEFORE %s // RUN: mlir-opt %s -run-reproducer 2>&1 | FileCheck -check-prefix=BEFORE %s
func @foo() { func @foo() {
%0 = arith.constant 0 : i32 %0 = arith.constant 0 : i32
Show All 13 Lines

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 {{'func.func' op with multiple blocks needs variables declared at top}}
func @multiple_blocks() { func @multiple_blocks() {
^bb1: ^bb1:
cf.br ^bb2 cf.br ^bb2
^bb2: ^bb2:
return return
} }
// ----- // -----
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

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

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

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

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

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

mlir/test/Transforms/canonicalize-dce.mlir

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

mlir/test/Transforms/canonicalize-td.mlir

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

mlir/test/Transforms/canonicalize.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.func(canonicalize)' -split-input-file | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func.func(canonicalize)' -split-input-file | FileCheck %s
// CHECK-LABEL: func @test_subi_zero // CHECK-LABEL: func @test_subi_zero
func @test_subi_zero(%arg0: i32) -> i32 { func @test_subi_zero(%arg0: i32) -> i32 {
// CHECK-NEXT: %c0_i32 = arith.constant 0 : i32 // CHECK-NEXT: %c0_i32 = arith.constant 0 : i32
// CHECK-NEXT: return %c0 // CHECK-NEXT: return %c0
%y = arith.subi %arg0, %arg0 : i32 %y = arith.subi %arg0, %arg0 : i32
return %y: i32 return %y: i32
} }
▲ Show 20 Lines • Show All 409 Lines • ▼ Show 20 Linesfunc @write_only_alloca_fold(%v: f32) {
%a = memref.alloca(%c4) : memref<?xf32> %a = memref.alloca(%c4) : memref<?xf32>
memref.store %v, %a[%c0] : memref<?xf32> memref.store %v, %a[%c0] : memref<?xf32>
return return
} }
// CHECK-LABEL: func @dead_block_elim // CHECK-LABEL: func @dead_block_elim
func @dead_block_elim() { func @dead_block_elim() {
// CHECK-NOT: ^bb // CHECK-NOT: ^bb
builtin.func @nested() { func.func @nested() {
return return
^bb1: ^bb1:
return return
} }
return return
^bb1: ^bb1:
▲ Show 20 Lines • Show All 816 Lines • Show Last 20 Lines

mlir/test/Transforms/constant-fold.mlir

Show First 20 Lines • Show All 752 Lines • ▼ Show 20 Lines
} }
// ----- // -----
// CHECK-LABEL: func @nested_isolated_region // CHECK-LABEL: func @nested_isolated_region
func @nested_isolated_region() { func @nested_isolated_region() {
// CHECK-NEXT: func @isolated_op // CHECK-NEXT: func @isolated_op
// CHECK-NEXT: arith.constant 2 // CHECK-NEXT: arith.constant 2
builtin.func @isolated_op() { func.func @isolated_op() {
%0 = arith.constant 1 : i32 %0 = arith.constant 1 : i32
%2 = arith.addi %0, %0 : i32 %2 = arith.addi %0, %0 : i32
"foo.yield"(%2) : (i32) -> () "foo.yield"(%2) : (i32) -> ()
} }
// CHECK: "foo.unknown_region" // CHECK: "foo.unknown_region"
// CHECK-NEXT: arith.constant 2 // CHECK-NEXT: arith.constant 2
"foo.unknown_region"() ({ "foo.unknown_region"() ({
Show All 30 Lines

mlir/test/Transforms/cse.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='builtin.func(cse)' | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func.func(cse)' | FileCheck %s
// CHECK-DAG: #[[$MAP:.*]] = affine_map<(d0) -> (d0 mod 2)> // CHECK-DAG: #[[$MAP:.*]] = affine_map<(d0) -> (d0 mod 2)>
#map0 = affine_map<(d0) -> (d0 mod 2)> #map0 = affine_map<(d0) -> (d0 mod 2)>
// CHECK-LABEL: @simple_constant // CHECK-LABEL: @simple_constant
func @simple_constant() -> (i32, i32) { func @simple_constant() -> (i32, 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
▲ Show 20 Lines • Show All 214 Lines • ▼ Show 20 Lines
/// This test checks that nested regions that are isolated from above are /// This test checks that nested regions that are isolated from above are
/// properly handled. /// properly handled.
// CHECK-LABEL: @nested_isolated // CHECK-LABEL: @nested_isolated
func @nested_isolated() -> i32 { func @nested_isolated() -> i32 {
// CHECK-NEXT: arith.constant 1 // CHECK-NEXT: arith.constant 1
%0 = arith.constant 1 : i32 %0 = arith.constant 1 : i32
// CHECK-NEXT: @nested_func // CHECK-NEXT: @nested_func
builtin.func @nested_func() { func.func @nested_func() {
// CHECK-NEXT: arith.constant 1 // CHECK-NEXT: arith.constant 1
%foo = arith.constant 1 : i32 %foo = arith.constant 1 : i32
"foo.yield"(%foo) : (i32) -> () "foo.yield"(%foo) : (i32) -> ()
} }
// CHECK: "foo.region" // CHECK: "foo.region"
"foo.region"() ({ "foo.region"() ({
// CHECK-NEXT: arith.constant 1 // CHECK-NEXT: arith.constant 1
Show All 27 Lines

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

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

mlir/test/Transforms/parametric-mapping.mlir

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

mlir/test/Transforms/print-op-graph.mlir

// RUN: mlir-opt -allow-unregistered-dialect -mlir-elide-elementsattrs-if-larger=2 -view-op-graph %s -o %t 2>&1 | FileCheck -check-prefix=DFG %s // RUN: mlir-opt -allow-unregistered-dialect -mlir-elide-elementsattrs-if-larger=2 -view-op-graph %s -o %t 2>&1 | FileCheck -check-prefix=DFG %s
// RUN: mlir-opt -allow-unregistered-dialect -mlir-elide-elementsattrs-if-larger=2 -view-op-graph='print-data-flow-edges=false print-control-flow-edges=true' %s -o %t 2>&1 | FileCheck -check-prefix=CFG %s // RUN: mlir-opt -allow-unregistered-dialect -mlir-elide-elementsattrs-if-larger=2 -view-op-graph='print-data-flow-edges=false print-control-flow-edges=true' %s -o %t 2>&1 | FileCheck -check-prefix=CFG %s
// DFG-LABEL: digraph G { // DFG-LABEL: digraph G {
// DFG: subgraph {{.*}} { // DFG: subgraph {{.*}} {
// DFG: subgraph {{.*}} // DFG: subgraph {{.*}}
// DFG: label = "builtin.func{{.*}}merge_blocks // DFG: label = "func.func{{.*}}merge_blocks
// DFG: subgraph {{.*}} { // DFG: subgraph {{.*}} {
// DFG: v[[ARG0:.*]] [label = "arg0" // DFG: v[[ARG0:.*]] [label = "arg0"
// DFG: v[[CONST10:.*]] [label ={{.*}}10 : i32 // DFG: v[[CONST10:.*]] [label ={{.*}}10 : i32
// DFG: subgraph [[CLUSTER_MERGE_BLOCKS:.*]] { // DFG: subgraph [[CLUSTER_MERGE_BLOCKS:.*]] {
// DFG: v[[ANCHOR:.*]] [label = " ", shape = plain] // DFG: v[[ANCHOR:.*]] [label = " ", shape = plain]
// DFG: label = "test.merge_blocks // DFG: label = "test.merge_blocks
// DFG: subgraph {{.*}} { // DFG: subgraph {{.*}} {
// DFG: v[[TEST_BR:.*]] [label = "test.br // DFG: v[[TEST_BR:.*]] [label = "test.br
// DFG: } // DFG: }
// DFG: subgraph {{.*}} { // DFG: subgraph {{.*}} {
// DFG: } // DFG: }
// DFG: } // DFG: }
// DFG: v[[TEST_RET:.*]] [label = "test.return // DFG: v[[TEST_RET:.*]] [label = "test.return
// DFG: v[[ARG0]] -> v[[TEST_BR]] // DFG: v[[ARG0]] -> v[[TEST_BR]]
// DFG: v[[CONST10]] -> v[[TEST_BR]] // DFG: v[[CONST10]] -> v[[TEST_BR]]
// DFG: v[[ANCHOR]] -> v[[TEST_RET]] [{{.*}}, ltail = [[CLUSTER_MERGE_BLOCKS]]] // DFG: v[[ANCHOR]] -> v[[TEST_RET]] [{{.*}}, ltail = [[CLUSTER_MERGE_BLOCKS]]]
// DFG: v[[ANCHOR]] -> v[[TEST_RET]] [{{.*}}, ltail = [[CLUSTER_MERGE_BLOCKS]]] // DFG: v[[ANCHOR]] -> v[[TEST_RET]] [{{.*}}, ltail = [[CLUSTER_MERGE_BLOCKS]]]
// CFG-LABEL: digraph G { // CFG-LABEL: digraph G {
// CFG: subgraph {{.*}} { // CFG: subgraph {{.*}} {
// CFG: subgraph {{.*}} // CFG: subgraph {{.*}}
// CFG: label = "builtin.func{{.*}}merge_blocks // CFG: label = "func.func{{.*}}merge_blocks
// CFG: subgraph {{.*}} { // CFG: subgraph {{.*}} {
// CFG: v[[C1:.*]] [label = "arith.constant // CFG: v[[C1:.*]] [label = "arith.constant
// CFG: v[[C2:.*]] [label = "arith.constant // CFG: v[[C2:.*]] [label = "arith.constant
// CFG: v[[C3:.*]] [label = "arith.constant // CFG: v[[C3:.*]] [label = "arith.constant
// CFG: v[[C4:.*]] [label = "arith.constant // CFG: v[[C4:.*]] [label = "arith.constant
// CFG: v[[TEST_FUNC:.*]] [label = "test.func // CFG: v[[TEST_FUNC:.*]] [label = "test.func
// CFG: subgraph [[CLUSTER_MERGE_BLOCKS:.*]] { // CFG: subgraph [[CLUSTER_MERGE_BLOCKS:.*]] {
// CFG: v[[ANCHOR:.*]] [label = " ", shape = plain] // CFG: v[[ANCHOR:.*]] [label = " ", shape = plain]
Show All 29 Lines

mlir/test/Transforms/sccp-structured.mlir

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

mlir/test/Transforms/sccp.mlir

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

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

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

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

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

mlir/test/Transforms/test-canonicalize.mlir

// RUN: mlir-opt %s -pass-pipeline='builtin.func(canonicalize)' | FileCheck %s // RUN: mlir-opt %s -pass-pipeline='func.func(canonicalize)' | FileCheck %s
// CHECK-LABEL: func @remove_op_with_inner_ops_pattern // CHECK-LABEL: func @remove_op_with_inner_ops_pattern
func @remove_op_with_inner_ops_pattern() { func @remove_op_with_inner_ops_pattern() {
// CHECK-NEXT: return // CHECK-NEXT: return
"test.op_with_region_pattern"() ({ "test.op_with_region_pattern"() ({
"test.op_with_region_terminator"() : () -> () "test.op_with_region_terminator"() : () -> ()
}) : () -> () }) : () -> ()
return return
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

mlir/test/Transforms/test-legalizer-analysis.mlir

// RUN: mlir-opt -allow-unregistered-dialect -test-legalize-patterns -verify-diagnostics -test-legalize-mode=analysis %s | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect -test-legalize-patterns -verify-diagnostics -test-legalize-mode=analysis %s | FileCheck %s
// expected-remark@-2 {{op 'builtin.module' is legalizable}} // expected-remark@-2 {{op 'builtin.module' is legalizable}}
// expected-remark@+1 {{op 'builtin.func' is legalizable}} // expected-remark@+1 {{op 'func.func' is legalizable}}
func @test(%arg0: f32) { func @test(%arg0: f32) {
// expected-remark@+1 {{op 'test.illegal_op_a' is legalizable}} // expected-remark@+1 {{op 'test.illegal_op_a' is legalizable}}
%result = "test.illegal_op_a"() : () -> (i32) %result = "test.illegal_op_a"() : () -> (i32)
"foo.region"() ({ "foo.region"() ({
// expected-remark@+1 {{op 'test.invalid' is legalizable}} // expected-remark@+1 {{op 'test.invalid' is legalizable}}
"test.invalid"() : () -> () "test.invalid"() : () -> ()
}) : () -> () }) : () -> ()
return return
} }
// Check that none of the legalizable operations were modified. // Check that none of the legalizable operations were modified.
// CHECK-LABEL: func @test // CHECK-LABEL: func @test
// CHECK-NEXT: "test.illegal_op_a" // CHECK-NEXT: "test.illegal_op_a"
// CHECK: "test.invalid" // CHECK: "test.invalid"

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

Show All 31 Lines
// Test that children of recursively legal operations are ignored. // Test that children of recursively legal operations are ignored.
func @recursively_legal_invalid_op() { func @recursively_legal_invalid_op() {
/// Operation that is statically legal. /// Operation that is statically legal.
builtin.module attributes {test.recursively_legal} { builtin.module attributes {test.recursively_legal} {
%ignored = "test.illegal_op_f"() : () -> (i32) %ignored = "test.illegal_op_f"() : () -> (i32)
} }
/// Operation that is dynamically legal, i.e. the function has a pattern /// Operation that is dynamically legal, i.e. the function has a pattern
/// applied to legalize the argument type before it becomes recursively legal. /// applied to legalize the argument type before it becomes recursively legal.
builtin.func @dynamic_func(%arg: i64) attributes {test.recursively_legal} { func.func @dynamic_func(%arg: i64) attributes {test.recursively_legal} {
%ignored = "test.illegal_op_f"() : () -> (i32) %ignored = "test.illegal_op_f"() : () -> (i32)
"test.return"() : () -> () "test.return"() : () -> ()
} }
"test.return"() : () -> () "test.return"() : () -> ()
} }
// ----- // -----
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/Affine/TestAffineDataCopy.cpp

//===- TestAffineDataCopy.cpp - Test affine data copy utility -------------===// //===- TestAffineDataCopy.cpp - Test affine data copy utility -------------===//
// //
// 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 test affine data copy utility functions and // This file implements a pass to test affine data copy utility functions and
// options. // options.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/Analysis/Utils.h" #include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h" #include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "mlir/Transforms/Passes.h" #include "mlir/Transforms/Passes.h"
#define PASS_NAME "test-affine-data-copy" #define PASS_NAME "test-affine-data-copy"
using namespace mlir; using namespace mlir;
static llvm::cl::OptionCategory clOptionsCategory(PASS_NAME " options");
mehdi_aminiUnsubmitted
Done
ReplyInline Actions

Oh that was just unused? This isn't related to this patch though right?

mehdi_amini: Oh that was just unused? This isn't related to this patch though right?
rriddleAuthorUnsubmitted
Done
ReplyInline Actions

Yep, also good point (will remove in an NFC patch before landing this).

rriddle: Yep, also good point (will remove in an NFC patch before landing this).
namespace { namespace {
struct TestAffineDataCopy struct TestAffineDataCopy
: public PassWrapper<TestAffineDataCopy, OperationPass<FuncOp>> { : public PassWrapper<TestAffineDataCopy, OperationPass<FuncOp>> {
StringRef getArgument() const final { return PASS_NAME; } StringRef getArgument() const final { return PASS_NAME; }
StringRef getDescription() const final { StringRef getDescription() const final {
return "Tests affine data copy utility functions."; return "Tests affine data copy utility functions.";
} }
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/Affine/TestAffineLoopParametricTiling.cpp

//= TestAffineLoopParametricTiling.cpp -- Parametric Affine loop tiling pass =// //= TestAffineLoopParametricTiling.cpp -- Parametric Affine loop tiling pass =//
// //
// 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 test pass to test parametric tiling of perfectly // This file implements a test pass to test parametric tiling of perfectly
// nested affine for loops. // nested affine for loops.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h" #include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Affine/Passes.h" #include "mlir/Dialect/Affine/Passes.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
using namespace mlir; using namespace mlir;
#define DEBUG_TYPE "test-affine-parametric-tile" #define DEBUG_TYPE "test-affine-parametric-tile"
namespace { namespace {
struct TestAffineLoopParametricTiling struct TestAffineLoopParametricTiling
: public PassWrapper<TestAffineLoopParametricTiling, : public PassWrapper<TestAffineLoopParametricTiling,
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/Affine/TestLoopFusion.cpp

//===- TestLoopFusion.cpp - Test loop fusion ------------------------------===// //===- TestLoopFusion.cpp - Test loop fusion ------------------------------===//
// //
// 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 test various loop fusion utility functions. // This file implements a pass to test various loop fusion utility functions.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/Analysis/Utils.h" #include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopFusionUtils.h" #include "mlir/Dialect/Affine/LoopFusionUtils.h"
#include "mlir/Dialect/Affine/LoopUtils.h" #include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#define DEBUG_TYPE "test-loop-fusion" #define DEBUG_TYPE "test-loop-fusion"
using namespace mlir; using namespace mlir;
static llvm::cl::OptionCategory clOptionsCategory(DEBUG_TYPE " options"); static llvm::cl::OptionCategory clOptionsCategory(DEBUG_TYPE " options");
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/Affine/TestVectorizationUtils.cpp

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Analysis/SliceAnalysis.h" #include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h" #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/NestedMatcher.h" #include "mlir/Dialect/Affine/Analysis/NestedMatcher.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h" #include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Affine/Utils.h" #include "mlir/Dialect/Affine/Utils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h" #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Diagnostics.h" #include "mlir/IR/Diagnostics.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/Passes.h" #include "mlir/Transforms/Passes.h"
▲ Show 20 Lines • Show All 251 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/Linalg/TestLinalgCodegenStrategy.cpp

//===- TestLinalgCodegenStrategy.cpp - Test Linalg codegen strategy -------===// //===- TestLinalgCodegenStrategy.cpp - Test Linalg codegen strategy -------===//
// //
// 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 logic for testing the Linalg codegen strategy. // This file implements logic for testing the Linalg codegen strategy.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <utility> #include <utility>
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/CodegenStrategy.h" #include "mlir/Dialect/Linalg/Transforms/CodegenStrategy.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
▲ Show 20 Lines • Show All 188 Lines • ▼ Show 20 Lines strategy
.setVectorTransferToSCFOptions( .setVectorTransferToSCFOptions(
VectorTransferToSCFOptions().enableFullUnroll( VectorTransferToSCFOptions().enableFullUnroll(
unrollVectorTransfers)) unrollVectorTransfers))
.enableTransferPartialRewrite() .enableTransferPartialRewrite()
.enableContractionLowering() .enableContractionLowering()
.enableTransferToSCFConversion()); .enableTransferToSCFConversion());
// Created a nested OpPassManager and run. // Created a nested OpPassManager and run.
FuncOp funcOp = getOperation(); FuncOp funcOp = getOperation();
OpPassManager dynamicPM("builtin.func"); OpPassManager dynamicPM("func.func");
strategy.configurePassPipeline(dynamicPM, funcOp.getContext(), runEnablePass); strategy.configurePassPipeline(dynamicPM, funcOp.getContext(), runEnablePass);
if (failed(runPipeline(dynamicPM, funcOp))) if (failed(runPipeline(dynamicPM, funcOp)))
return signalPassFailure(); return signalPassFailure();
} }
} // namespace } // namespace
// For now, just assume it is the zero of type. // For now, just assume it is the zero of type.
// In the future, it should be the zero of type + op. // In the future, it should be the zero of type + op.
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/Linalg/TestLinalgElementwiseFusion.cpp

//===- TestLinalgElementwiseFusion.cpp - Test Linalg elementwise fusion ---===// //===- TestLinalgElementwiseFusion.cpp - Test Linalg elementwise fusion ---===//
// //
// 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 for testing fusion of elementwise operations in // This file implements a pass for testing fusion of elementwise operations in
// Linalg, mainly linalg options. // Linalg, mainly linalg options.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Pass/PassManager.h" #include "mlir/Pass/PassManager.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "llvm/ADT/TypeSwitch.h" #include "llvm/ADT/TypeSwitch.h"
namespace mlir { namespace mlir {
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/Linalg/TestLinalgFusionTransforms.cpp

//===- TestLinalgFusionTransforms.cpp - Test Linalg fusion patterns -------===// //===- TestLinalgFusionTransforms.cpp - Test Linalg fusion 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements logic for testing Linalg fusion patterns. // This file implements logic for testing Linalg fusion patterns.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h" #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Transforms.h" #include "mlir/Dialect/SCF/Transforms.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.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"
▲ Show 20 Lines • Show All 313 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/Linalg/TestLinalgHoisting.cpp

//===- TestLinalgHoisting.cpp - Test Linalg hoisting functions ------------===// //===- TestLinalgHoisting.cpp - Test Linalg hoisting functions ------------===//
// //
// 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 logic for testing Linalg hoisting functions. // This file implements logic for testing Linalg hoisting functions.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Hoisting.h" #include "mlir/Dialect/Linalg/Transforms/Hoisting.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
using namespace mlir; using namespace mlir;
using namespace mlir::linalg; using namespace mlir::linalg;
namespace { namespace {
Show All 34 Lines

mlir/test/lib/Dialect/Linalg/TestLinalgTransforms.cpp

//===- TestLinalgTransforms.cpp - Test Linalg transformation patterns -----===// //===- TestLinalgTransforms.cpp - Test Linalg transformation 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements logic for testing Linalg transformations. // This file implements logic for testing Linalg transformations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#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/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.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/Linalg/Transforms/HoistPadding.h" #include "mlir/Dialect/Linalg/Transforms/HoistPadding.h"
#include "mlir/Dialect/Linalg/Transforms/Hoisting.h" #include "mlir/Dialect/Linalg/Transforms/Hoisting.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h" #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h" #include "mlir/Dialect/Vector/IR/VectorOps.h"
▲ Show 20 Lines • Show All 654 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp

//===- TestSCFUtils.cpp --- Pass to test independent SCF dialect utils ----===// //===- TestSCFUtils.cpp --- Pass to test independent SCF dialect utils ----===//
// //
// 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 test SCF dialect utils. // This file implements a pass to test SCF dialect utils.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Dialect/SCF/Transforms.h" #include "mlir/Dialect/SCF/Transforms.h"
#include "mlir/Dialect/SCF/Utils/Utils.h" #include "mlir/Dialect/SCF/Utils/Utils.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"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/SPIRV/TestAvailability.cpp

//===- TestAvailability.cpp - Pass to test SPIR-V op availability ---------===// //===- TestAvailability.cpp - Pass to test SPIR-V op availability ---------===//
// //
// 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/Func/IR/FuncOps.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 231 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/Test/TestDialect.h

Show All 12 Lines
#ifndef MLIR_TESTDIALECT_H #ifndef MLIR_TESTDIALECT_H
#define MLIR_TESTDIALECT_H #define MLIR_TESTDIALECT_H
#include "TestAttributes.h" #include "TestAttributes.h"
#include "TestInterfaces.h" #include "TestInterfaces.h"
#include "mlir/Dialect/DLTI/DLTI.h" #include "mlir/Dialect/DLTI/DLTI.h"
#include "mlir/Dialect/DLTI/Traits.h" #include "mlir/Dialect/DLTI/Traits.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h" #include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Traits.h" #include "mlir/Dialect/Traits.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/OpDefinition.h" #include "mlir/IR/OpDefinition.h"
#include "mlir/IR/OpImplementation.h" #include "mlir/IR/OpImplementation.h"
#include "mlir/IR/RegionKindInterface.h" #include "mlir/IR/RegionKindInterface.h"
Show All 26 Lines

mlir/test/lib/Dialect/Tosa/CMakeLists.txt

add_mlir_dialect_library(MLIRTosaTestPasses add_mlir_dialect_library(MLIRTosaTestPasses
TosaTestPasses.cpp TosaTestPasses.cpp
EXCLUDE_FROM_LIBMLIR EXCLUDE_FROM_LIBMLIR
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Tosa/Transforms ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Tosa/Transforms
DEPENDS DEPENDS
MLIRTosaPassIncGen MLIRTosaPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRFunc
MLIRPass MLIRPass
MLIRTosa MLIRTosa
MLIRTransformUtils MLIRTransformUtils
) )

mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp

Show First 20 Lines • Show All 233 Lines • ▼ Show 20 Lines void runOnOperation() override {
if (lowerToAvx2) { if (lowerToAvx2) {
options = options.enableAVX2Lowering().setAVX2LoweringOptions( options = options.enableAVX2Lowering().setAVX2LoweringOptions(
x86vector::avx2::LoweringOptions().setTransposeOptions( x86vector::avx2::LoweringOptions().setTransposeOptions(
x86vector::avx2::TransposeLoweringOptions() x86vector::avx2::TransposeLoweringOptions()
.lower4x8xf32() .lower4x8xf32()
.lower8x8xf32())); .lower8x8xf32()));
} }
OpPassManager dynamicPM("builtin.func"); OpPassManager dynamicPM("func.func");
dynamicPM.addPass(createLinalgStrategyLowerVectorsPass(options)); dynamicPM.addPass(createLinalgStrategyLowerVectorsPass(options));
if (failed(runPipeline(dynamicPM, getOperation()))) if (failed(runPipeline(dynamicPM, getOperation())))
return signalPassFailure(); return signalPassFailure();
} }
}; };
struct TestVectorUnrollingPatterns struct TestVectorUnrollingPatterns
: public PassWrapper<TestVectorUnrollingPatterns, OperationPass<FuncOp>> { : public PassWrapper<TestVectorUnrollingPatterns, OperationPass<FuncOp>> {
▲ Show 20 Lines • Show All 439 Lines • Show Last 20 Lines

mlir/test/lib/Pass/TestPassManager.cpp

//===- TestPassManager.cpp - Test pass manager functionality --------------===// //===- TestPassManager.cpp - Test pass manager functionality --------------===//
// //
// 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 "TestDialect.h" #include "TestDialect.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Pass/PassManager.h" #include "mlir/Pass/PassManager.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
struct TestModulePass struct TestModulePass
▲ Show 20 Lines • Show All 178 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -pass-pipeline="async-to-async-runtime,builtin.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,builtin.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,convert-vector-to-llvm,builtin.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,convert-vector-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \
// RUN: | mlir-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 \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
func @main() { func @main() {
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -pass-pipeline="async-to-async-runtime,builtin.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,builtin.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \
// RUN: | mlir-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 \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// This is crashing in CI "most of the time" on a AMD Rome CPU VM on GCP with: // This is crashing in CI "most of the time" on a AMD Rome CPU VM on GCP with:
Show All 40 Lines

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

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

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

// RUN: mlir-opt %s -pass-pipeline="async-to-async-runtime,builtin.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,builtin.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,convert-memref-to-llvm,builtin.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,convert-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \
// RUN: | mlir-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 \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @main() { func @main() {
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -pass-pipeline="builtin.func(convert-scf-to-cf,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm{use-bare-ptr-memref-call-conv=1}" -reconcile-unrealized-casts | mlir-cpu-runner -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext -entry-point-result=void | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="func.func(convert-scf-to-cf,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm{use-bare-ptr-memref-call-conv=1}" -reconcile-unrealized-casts | mlir-cpu-runner -shared-libs=%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 -pass-pipeline="builtin.func(convert-scf-to-cf,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="func.func(convert-scf-to-cf,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" \
// RUN: | mlir-cpu-runner -e main -entry-point-result=void \ // RUN: | mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_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/global-memref.mlir

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

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

// RUN: mlir-opt %s -pass-pipeline="builtin.func(test-math-polynomial-approximation,convert-arith-to-llvm),convert-vector-to-llvm,builtin.func(convert-math-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="func.func(test-math-polynomial-approximation,convert-arith-to-llvm),convert-vector-to-llvm,func.func(convert-math-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \
// RUN: | mlir-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 \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// -------------------------------------------------------------------------- // // -------------------------------------------------------------------------- //
// Tanh. // Tanh.
▲ Show 20 Lines • Show All 505 Lines • Show Last 20 Lines

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

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

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

// RUN: mlir-opt %s -pass-pipeline="builtin.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e print_0d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-0D // RUN: mlir-opt %s -pass-pipeline="func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e print_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 -pass-pipeline="builtin.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e print_1d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-1D // RUN: mlir-opt %s -pass-pipeline="func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e print_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 -pass-pipeline="builtin.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e print_3d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-3D // RUN: mlir-opt %s -pass-pipeline="func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e 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 -pass-pipeline="builtin.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e vector_splat_2d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-VECTOR-SPLAT-2D // RUN: mlir-opt %s -pass-pipeline="func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" | mlir-cpu-runner -e vector_splat_2d -entry-point-result=void -shared-libs=%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/diagnostics.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 ()" "text":"func ()"
}}} }}}
// CHECK: "method": "textDocument/publishDiagnostics", // CHECK: "method": "textDocument/publishDiagnostics",
// CHECK-NEXT: "params": { // CHECK-NEXT: "params": {
// CHECK-NEXT: "diagnostics": [ // CHECK-NEXT: "diagnostics": [
// CHECK-NEXT: { // CHECK-NEXT: {
// CHECK-NEXT: "category": "Parse Error", // CHECK-NEXT: "category": "Parse Error",
// CHECK-NEXT: "message": "custom op 'builtin.func' expected valid '@'-identifier for symbol name", // CHECK-NEXT: "message": "custom op 'func.func' expected valid '@'-identifier for symbol name",
// CHECK-NEXT: "range": { // CHECK-NEXT: "range": {
// CHECK-NEXT: "end": { // CHECK-NEXT: "end": {
// CHECK-NEXT: "character": 7, // CHECK-NEXT: "character": 7,
// CHECK-NEXT: "line": 0 // CHECK-NEXT: "line": 0
// CHECK-NEXT: }, // CHECK-NEXT: },
// CHECK-NEXT: "start": { // CHECK-NEXT: "start": {
// CHECK-NEXT: "character": 6, // CHECK-NEXT: "character": 6,
// CHECK-NEXT: "line": 0 // CHECK-NEXT: "line": 0
Show All 13 Lines

mlir/test/mlir-lsp-server/hover.test

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines// Hover on a Block.
"textDocument":{"uri":"test:///foo.mlir"}, "textDocument":{"uri":"test:///foo.mlir"},
"position":{"line":3,"character":2} "position":{"line":3,"character":2}
}} }}
// CHECK: "id": 3, // CHECK: "id": 3,
// CHECK-NEXT: "jsonrpc": "2.0", // CHECK-NEXT: "jsonrpc": "2.0",
// CHECK-NEXT: "result": { // CHECK-NEXT: "result": {
// CHECK-NEXT: "contents": { // CHECK-NEXT: "contents": {
// CHECK-NEXT: "kind": "markdown", // CHECK-NEXT: "kind": "markdown",
// CHECK-NEXT: "value": "Operation: \"builtin.func\"\n\nBlock #1\n\nPredecessors: <Block #0>\n\n" // CHECK-NEXT: "value": "Operation: \"func.func\"\n\nBlock #1\n\nPredecessors: <Block #0>\n\n"
// CHECK-NEXT: }, // CHECK-NEXT: },
// CHECK-NEXT: "range": { // CHECK-NEXT: "range": {
// CHECK-NEXT: "end": { // CHECK-NEXT: "end": {
// CHECK-NEXT: "character": 4, // CHECK-NEXT: "character": 4,
// CHECK-NEXT: "line": 3 // CHECK-NEXT: "line": 3
// CHECK-NEXT: }, // CHECK-NEXT: },
// CHECK-NEXT: "start": { // CHECK-NEXT: "start": {
// CHECK-NEXT: "character": 0, // CHECK-NEXT: "character": 0,
// CHECK-NEXT: "line": 3 // CHECK-NEXT: "line": 3
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// ----- // -----
// Hover on a Block argument. // Hover on a Block argument.
{"jsonrpc":"2.0","id":4,"method":"textDocument/hover","params":{ {"jsonrpc":"2.0","id":4,"method":"textDocument/hover","params":{
"textDocument":{"uri":"test:///foo.mlir"}, "textDocument":{"uri":"test:///foo.mlir"},
"position":{"line":0,"character":12} "position":{"line":0,"character":12}
}} }}
// CHECK: "id": 4, // CHECK: "id": 4,
// CHECK-NEXT: "jsonrpc": "2.0", // CHECK-NEXT: "jsonrpc": "2.0",
// CHECK-NEXT: "result": { // CHECK-NEXT: "result": {
// CHECK-NEXT: "contents": { // CHECK-NEXT: "contents": {
// CHECK-NEXT: "kind": "markdown", // CHECK-NEXT: "kind": "markdown",
// CHECK-NEXT: "value": "Operation: \"builtin.func\"\n\nBlock: <Block #0>\n\nArgument #0\n\nType: `i1`\n\n" // CHECK-NEXT: "value": "Operation: \"func.func\"\n\nBlock: <Block #0>\n\nArgument #0\n\nType: `i1`\n\n"
// CHECK-NEXT: }, // CHECK-NEXT: },
// CHECK-NEXT: "range": { // CHECK-NEXT: "range": {
// CHECK-NEXT: "end": { // CHECK-NEXT: "end": {
// CHECK-NEXT: "character": 14, // CHECK-NEXT: "character": 14,
// CHECK-NEXT: "line": 0 // CHECK-NEXT: "line": 0
// CHECK-NEXT: }, // CHECK-NEXT: },
// CHECK-NEXT: "start": { // CHECK-NEXT: "start": {
// CHECK-NEXT: "character": 10, // CHECK-NEXT: "character": 10,
// CHECK-NEXT: "line": 0 // CHECK-NEXT: "line": 0
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// ----- // -----
// Hover on a region operation. // Hover on a region operation.
{"jsonrpc":"2.0","id":5,"method":"textDocument/hover","params":{ {"jsonrpc":"2.0","id":5,"method":"textDocument/hover","params":{
"textDocument":{"uri":"test:///foo.mlir"}, "textDocument":{"uri":"test:///foo.mlir"},
"position":{"line":0,"character":1} "position":{"line":0,"character":1}
}} }}
// CHECK: "id": 5, // CHECK: "id": 5,
// CHECK-NEXT: "jsonrpc": "2.0", // CHECK-NEXT: "jsonrpc": "2.0",
// CHECK-NEXT: "result": { // CHECK-NEXT: "result": {
// CHECK-NEXT: "contents": { // CHECK-NEXT: "contents": {
// CHECK-NEXT: "kind": "markdown", // CHECK-NEXT: "kind": "markdown",
// CHECK-NEXT: "value": "\"builtin.func\" : public @foo\n\nGeneric Form:\n\n```mlir\n\"builtin.func\"() ({\n}) {sym_name = \"foo\", type = (i1) -> ()} : () -> ()\n```\n" // CHECK-NEXT: "value": "\"func.func\" : public @foo\n\nGeneric Form:\n\n```mlir\n\"func.func\"() ({\n}) {sym_name = \"foo\", type = (i1) -> ()} : () -> ()\n```\n"
// CHECK-NEXT: }, // CHECK-NEXT: },
// CHECK-NEXT: "range": { // CHECK-NEXT: "range": {
// CHECK-NEXT: "end": { // CHECK-NEXT: "end": {
// CHECK-NEXT: "character": 4, // CHECK-NEXT: "character": 4,
// CHECK-NEXT: "line": 0 // CHECK-NEXT: "line": 0
// CHECK-NEXT: }, // CHECK-NEXT: },
// CHECK-NEXT: "start": { // CHECK-NEXT: "start": {
// CHECK-NEXT: "character": 0, // CHECK-NEXT: "character": 0,
// CHECK-NEXT: "line": 0 // CHECK-NEXT: "line": 0
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// ----- // -----
// Hover on a symbol reference. // Hover on a symbol reference.
{"jsonrpc":"2.0","id":6,"method":"textDocument/hover","params":{ {"jsonrpc":"2.0","id":6,"method":"textDocument/hover","params":{
"textDocument":{"uri":"test:///foo.mlir"}, "textDocument":{"uri":"test:///foo.mlir"},
"position":{"line":0,"character":8} "position":{"line":0,"character":8}
}} }}
// CHECK: "id": 6, // CHECK: "id": 6,
// CHECK-NEXT: "jsonrpc": "2.0", // CHECK-NEXT: "jsonrpc": "2.0",
// CHECK-NEXT: "result": { // CHECK-NEXT: "result": {
// CHECK-NEXT: "contents": { // CHECK-NEXT: "contents": {
// CHECK-NEXT: "kind": "markdown", // CHECK-NEXT: "kind": "markdown",
// CHECK-NEXT: "value": "\"builtin.func\" : public @foo\n\nGeneric Form:\n\n```mlir\n\"builtin.func\"() ({\n}) {sym_name = \"foo\", type = (i1) -> ()} : () -> ()\n```\n" // CHECK-NEXT: "value": "\"func.func\" : public @foo\n\nGeneric Form:\n\n```mlir\n\"func.func\"() ({\n}) {sym_name = \"foo\", type = (i1) -> ()} : () -> ()\n```\n"
// CHECK-NEXT: }, // CHECK-NEXT: },
// CHECK-NEXT: "range": { // CHECK-NEXT: "range": {
// CHECK-NEXT: "end": { // CHECK-NEXT: "end": {
// CHECK-NEXT: "character": 9, // CHECK-NEXT: "character": 9,
// CHECK-NEXT: "line": 0 // CHECK-NEXT: "line": 0
// CHECK-NEXT: }, // CHECK-NEXT: },
// CHECK-NEXT: "start": { // CHECK-NEXT: "start": {
// CHECK-NEXT: "character": 5, // CHECK-NEXT: "character": 5,
// CHECK-NEXT: "line": 0 // CHECK-NEXT: "line": 0
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// ----- // -----
{"jsonrpc":"2.0","id":7,"method":"shutdown"} {"jsonrpc":"2.0","id":7,"method":"shutdown"}
// ----- // -----
{"jsonrpc":"2.0","method":"exit"} {"jsonrpc":"2.0","method":"exit"}

mlir/test/mlir-opt/async.mlir

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

mlir/test/mlir-pdll/Parser/expr-failure.pdll

Show First 20 Lines • Show All 200 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// `op` Expr // `op` Expr
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Pattern { Pattern {
// CHECK: expected `)` after operation operand list // CHECK: expected `)` after operation operand list
let value: Value; let value: Value;
let foo = op<builtin.func>(value<; let foo = op<func.func>(value<;
} }
// ----- // -----
Pattern { Pattern {
// CHECK: unable to convert expression of type `Attr` to the expected type of `ValueRange` // CHECK: unable to convert expression of type `Attr` to the expected type of `ValueRange`
let attr: Attr; let attr: Attr;
let foo = op<builtin.func>(attr); let foo = op<func.func>(attr);
} }
// ----- // -----
Pattern { Pattern {
// CHECK: expected `Value` or `ValueRange` convertible expression, but got `Type` // CHECK: expected `Value` or `ValueRange` convertible expression, but got `Type`
let foo = op<>(_: Type, _: TypeRange); let foo = op<>(_: Type, _: TypeRange);
} }
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

mlir/test/mlir-pdll/Parser/stmt-failure.pdll

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 LinesPattern {
// CHECK: expected operation name after dialect namespace // CHECK: expected operation name after dialect namespace
let foo: Op<builtin.>; let foo: Op<builtin.>;
} }
// ----- // -----
Pattern { Pattern {
// CHECK: expected `>` after operation name // CHECK: expected `>` after operation name
let foo: Op<builtin.func<; let foo: Op<func.func<;
} }
// ----- // -----
Pattern { Pattern {
// CHECK: expected expression // CHECK: expected expression
let foo: Value<>; let foo: Value<>;
} }
▲ Show 20 Lines • Show All 275 Lines • Show Last 20 Lines

mlir/test/python/dialects/builtin.py

Show All 16 Linesdef testFromPyFunc():
with Context() as ctx, Location.unknown() as loc: with Context() as ctx, Location.unknown() as loc:
ctx.allow_unregistered_dialects = True ctx.allow_unregistered_dialects = True
m = builtin.ModuleOp() m = builtin.ModuleOp()
f32 = F32Type.get() f32 = F32Type.get()
f64 = F64Type.get() f64 = F64Type.get()
with InsertionPoint(m.body): with InsertionPoint(m.body):
# CHECK-LABEL: func @unary_return(%arg0: f64) -> f64 # CHECK-LABEL: func @unary_return(%arg0: f64) -> f64
# CHECK: return %arg0 : f64 # CHECK: return %arg0 : f64
@builtin.FuncOp.from_py_func(f64) @func.FuncOp.from_py_func(f64)
def unary_return(a): def unary_return(a):
return a return a
# CHECK-LABEL: func @binary_return(%arg0: f32, %arg1: f64) -> (f32, f64) # CHECK-LABEL: func @binary_return(%arg0: f32, %arg1: f64) -> (f32, f64)
# CHECK: return %arg0, %arg1 : f32, f64 # CHECK: return %arg0, %arg1 : f32, f64
@builtin.FuncOp.from_py_func(f32, f64) @func.FuncOp.from_py_func(f32, f64)
def binary_return(a, b): def binary_return(a, b):
return a, b return a, b
# CHECK-LABEL: func @none_return(%arg0: f32, %arg1: f64) # CHECK-LABEL: func @none_return(%arg0: f32, %arg1: f64)
# CHECK: return # CHECK: return
@builtin.FuncOp.from_py_func(f32, f64) @func.FuncOp.from_py_func(f32, f64)
def none_return(a, b): def none_return(a, b):
pass pass
# CHECK-LABEL: func @call_unary # CHECK-LABEL: func @call_unary
# CHECK: %0 = call @unary_return(%arg0) : (f64) -> f64 # CHECK: %0 = call @unary_return(%arg0) : (f64) -> f64
# CHECK: return %0 : f64 # CHECK: return %0 : f64
@builtin.FuncOp.from_py_func(f64) @func.FuncOp.from_py_func(f64)
def call_unary(a): def call_unary(a):
return unary_return(a) return unary_return(a)
# CHECK-LABEL: func @call_binary # CHECK-LABEL: func @call_binary
# CHECK: %0:2 = call @binary_return(%arg0, %arg1) : (f32, f64) -> (f32, f64) # CHECK: %0:2 = call @binary_return(%arg0, %arg1) : (f32, f64) -> (f32, f64)
# CHECK: return %0#0, %0#1 : f32, f64 # CHECK: return %0#0, %0#1 : f32, f64
@builtin.FuncOp.from_py_func(f32, f64) @func.FuncOp.from_py_func(f32, f64)
def call_binary(a, b): def call_binary(a, b):
return binary_return(a, b) return binary_return(a, b)
# We expect coercion of a single result operation to a returned value. # We expect coercion of a single result operation to a returned value.
# CHECK-LABEL: func @single_result_op # CHECK-LABEL: func @single_result_op
# CHECK: %0 = "custom.op1"() : () -> f32 # CHECK: %0 = "custom.op1"() : () -> f32
# CHECK: return %0 : f32 # CHECK: return %0 : f32
@builtin.FuncOp.from_py_func() @func.FuncOp.from_py_func()
def single_result_op(): def single_result_op():
return Operation.create("custom.op1", results=[f32]) return Operation.create("custom.op1", results=[f32])
# CHECK-LABEL: func @call_none # CHECK-LABEL: func @call_none
# CHECK: call @none_return(%arg0, %arg1) : (f32, f64) -> () # CHECK: call @none_return(%arg0, %arg1) : (f32, f64) -> ()
# CHECK: return # CHECK: return
@builtin.FuncOp.from_py_func(f32, f64) @func.FuncOp.from_py_func(f32, f64)
def call_none(a, b): def call_none(a, b):
return none_return(a, b) return none_return(a, b)
## Variants and optional feature tests. ## Variants and optional feature tests.
# CHECK-LABEL: func @from_name_arg # CHECK-LABEL: func @from_name_arg
@builtin.FuncOp.from_py_func(f32, f64, name="from_name_arg") @func.FuncOp.from_py_func(f32, f64, name="from_name_arg")
def explicit_name(a, b): def explicit_name(a, b):
return b return b
@builtin.FuncOp.from_py_func(f32, f64) @func.FuncOp.from_py_func(f32, f64)
def positional_func_op(a, b, func_op): def positional_func_op(a, b, func_op):
assert isinstance(func_op, builtin.FuncOp) assert isinstance(func_op, func.FuncOp)
return b return b
@builtin.FuncOp.from_py_func(f32, f64) @func.FuncOp.from_py_func(f32, f64)
def kw_func_op(a, b=None, func_op=None): def kw_func_op(a, b=None, func_op=None):
assert isinstance(func_op, builtin.FuncOp) assert isinstance(func_op, func.FuncOp)
return b return b
@builtin.FuncOp.from_py_func(f32, f64) @func.FuncOp.from_py_func(f32, f64)
def kwargs_func_op(a, b=None, **kwargs): def kwargs_func_op(a, b=None, **kwargs):
assert isinstance(kwargs["func_op"], builtin.FuncOp) assert isinstance(kwargs["func_op"], func.FuncOp)
return b return b
# CHECK-LABEL: func @explicit_results(%arg0: f32, %arg1: f64) -> f64 # CHECK-LABEL: func @explicit_results(%arg0: f32, %arg1: f64) -> f64
# CHECK: return %arg1 : f64 # CHECK: return %arg1 : f64
@builtin.FuncOp.from_py_func(f32, f64, results=[f64]) @func.FuncOp.from_py_func(f32, f64, results=[f64])
def explicit_results(a, b): def explicit_results(a, b):
func.ReturnOp([b]) func.ReturnOp([b])
print(m) print(m)
# CHECK-LABEL: TEST: testFromPyFuncErrors # CHECK-LABEL: TEST: testFromPyFuncErrors
@run @run
def testFromPyFuncErrors(): def testFromPyFuncErrors():
with Context() as ctx, Location.unknown() as loc: with Context() as ctx, Location.unknown() as loc:
m = builtin.ModuleOp() m = builtin.ModuleOp()
f32 = F32Type.get() f32 = F32Type.get()
f64 = F64Type.get() f64 = F64Type.get()
with InsertionPoint(m.body): with InsertionPoint(m.body):
try: try:
@builtin.FuncOp.from_py_func(f64, results=[f64]) @func.FuncOp.from_py_func(f64, results=[f64])
def unary_return(a): def unary_return(a):
return a return a
except AssertionError as e: except AssertionError as e:
# CHECK: Capturing a python function with explicit `results=` requires that the wrapped function returns None. # CHECK: Capturing a python function with explicit `results=` requires that the wrapped function returns None.
print(e) print(e)
# CHECK-LABEL: TEST: testBuildFuncOp # CHECK-LABEL: TEST: testBuildFuncOp
@run @run
def testBuildFuncOp(): def testBuildFuncOp():
ctx = Context() ctx = Context()
with Location.unknown(ctx) as loc: with Location.unknown(ctx) as loc:
m = builtin.ModuleOp() m = builtin.ModuleOp()
f32 = F32Type.get() f32 = F32Type.get()
tensor_type = RankedTensorType.get((2, 3, 4), f32) tensor_type = RankedTensorType.get((2, 3, 4), f32)
with InsertionPoint.at_block_begin(m.body): with InsertionPoint.at_block_begin(m.body):
f = builtin.FuncOp(name="some_func", f = func.FuncOp(name="some_func",
type=FunctionType.get( type=FunctionType.get(
inputs=[tensor_type, tensor_type], inputs=[tensor_type, tensor_type],
results=[tensor_type]), results=[tensor_type]),
visibility="nested") visibility="nested")
# CHECK: Name is: "some_func" # CHECK: Name is: "some_func"
print("Name is: ", f.name) print("Name is: ", f.name)
# CHECK: Type is: (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32> # CHECK: Type is: (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
Show All 14 Lines with InsertionPoint.at_block_begin(m.body):
try: try:
f.add_entry_block() f.add_entry_block()
except IndexError as e: except IndexError as e:
# CHECK: The function already has an entry block! # CHECK: The function already has an entry block!
print(e) print(e)
# Try the callback builder and passing type as tuple. # Try the callback builder and passing type as tuple.
f = builtin.FuncOp(name="some_other_func", f = func.FuncOp(name="some_other_func",
type=([tensor_type, tensor_type], [tensor_type]), type=([tensor_type, tensor_type], [tensor_type]),
visibility="nested", visibility="nested",
body_builder=lambda f: func.ReturnOp( body_builder=lambda f: func.ReturnOp(
[f.entry_block.arguments[0]])) [f.entry_block.arguments[0]]))
# CHECK: module { # CHECK: module {
# CHECK: func nested @some_func(%arg0: tensor<2x3x4xf32>, %arg1: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> { # CHECK: func nested @some_func(%arg0: tensor<2x3x4xf32>, %arg1: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {
# CHECK: return %arg0 : tensor<2x3x4xf32> # CHECK: return %arg0 : tensor<2x3x4xf32>
# CHECK: } # CHECK: }
# CHECK: func nested @some_other_func(%arg0: tensor<2x3x4xf32>, %arg1: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> { # CHECK: func nested @some_other_func(%arg0: tensor<2x3x4xf32>, %arg1: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {
# CHECK: return %arg0 : tensor<2x3x4xf32> # CHECK: return %arg0 : tensor<2x3x4xf32>
# CHECK: } # CHECK: }
print(m) print(m)
# CHECK-LABEL: TEST: testFuncArgumentAccess # CHECK-LABEL: TEST: testFuncArgumentAccess
@run @run
def testFuncArgumentAccess(): def testFuncArgumentAccess():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
ctx.allow_unregistered_dialects = True ctx.allow_unregistered_dialects = True
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
f64 = F64Type.get() f64 = F64Type.get()
with InsertionPoint(module.body): with InsertionPoint(module.body):
f = builtin.FuncOp("some_func", ([f32, f32], [f32, f32])) f = func.FuncOp("some_func", ([f32, f32], [f32, f32]))
with InsertionPoint(f.add_entry_block()): with InsertionPoint(f.add_entry_block()):
func.ReturnOp(f.arguments) func.ReturnOp(f.arguments)
f.arg_attrs = ArrayAttr.get([ f.arg_attrs = ArrayAttr.get([
DictAttr.get({ DictAttr.get({
"custom_dialect.foo": StringAttr.get("bar"), "custom_dialect.foo": StringAttr.get("bar"),
"custom_dialect.baz": UnitAttr.get() "custom_dialect.baz": UnitAttr.get()
}), }),
DictAttr.get({"custom_dialect.qux": ArrayAttr.get([])}) DictAttr.get({"custom_dialect.qux": ArrayAttr.get([])})
]) ])
f.result_attrs = ArrayAttr.get([ f.result_attrs = ArrayAttr.get([
DictAttr.get({"custom_dialect.res1": FloatAttr.get(f32, 42.0)}), DictAttr.get({"custom_dialect.res1": FloatAttr.get(f32, 42.0)}),
DictAttr.get({"custom_dialect.res2": FloatAttr.get(f64, 256.0)}) DictAttr.get({"custom_dialect.res2": FloatAttr.get(f64, 256.0)})
]) ])
other = builtin.FuncOp("other_func", ([f32, f32], [])) other = func.FuncOp("other_func", ([f32, f32], []))
with InsertionPoint(other.add_entry_block()): with InsertionPoint(other.add_entry_block()):
func.ReturnOp([]) func.ReturnOp([])
other.arg_attrs = [ other.arg_attrs = [
DictAttr.get({"custom_dialect.foo": StringAttr.get("qux")}), DictAttr.get({"custom_dialect.foo": StringAttr.get("qux")}),
DictAttr.get() DictAttr.get()
] ]
# CHECK: [{custom_dialect.baz, custom_dialect.foo = "bar"}, {custom_dialect.qux = []}] # CHECK: [{custom_dialect.baz, custom_dialect.foo = "bar"}, {custom_dialect.qux = []}]
Show All 16 Lines

mlir/test/python/dialects/func.py

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
# CHECK: = arith.constant 10 : index # CHECK: = arith.constant 10 : index
# CHECK-LABEL: TEST: testFunctionCalls # CHECK-LABEL: TEST: testFunctionCalls
@constructAndPrintInModule @constructAndPrintInModule
def testFunctionCalls(): def testFunctionCalls():
foo = builtin.FuncOp("foo", ([], [])) foo = func.FuncOp("foo", ([], []))
foo.sym_visibility = StringAttr.get("private") foo.sym_visibility = StringAttr.get("private")
bar = builtin.FuncOp("bar", ([], [IndexType.get()])) bar = func.FuncOp("bar", ([], [IndexType.get()]))
bar.sym_visibility = StringAttr.get("private") bar.sym_visibility = StringAttr.get("private")
qux = builtin.FuncOp("qux", ([], [F32Type.get()])) qux = func.FuncOp("qux", ([], [F32Type.get()]))
qux.sym_visibility = StringAttr.get("private") qux.sym_visibility = StringAttr.get("private")
with InsertionPoint(builtin.FuncOp("caller", ([], [])).add_entry_block()): with InsertionPoint(func.FuncOp("caller", ([], [])).add_entry_block()):
func.CallOp(foo, []) func.CallOp(foo, [])
func.CallOp([IndexType.get()], "bar", []) func.CallOp([IndexType.get()], "bar", [])
func.CallOp([F32Type.get()], FlatSymbolRefAttr.get("qux"), []) func.CallOp([F32Type.get()], FlatSymbolRefAttr.get("qux"), [])
func.ReturnOp([]) func.ReturnOp([])
# CHECK: func private @foo() # CHECK: func private @foo()
# CHECK: func private @bar() -> index # CHECK: func private @bar() -> index
# CHECK: func private @qux() -> f32 # CHECK: func private @qux() -> f32
# CHECK: func @caller() { # CHECK: func @caller() {
# CHECK: call @foo() : () -> () # CHECK: call @foo() : () -> ()
# CHECK: %0 = call @bar() : () -> index # CHECK: %0 = call @bar() : () -> index
# CHECK: %1 = call @qux() : () -> f32 # CHECK: %1 = call @qux() : () -> f32
# CHECK: return # CHECK: return
# CHECK: } # CHECK: }

mlir/test/python/dialects/linalg/opdsl/emit_convolution.py

Show All 40 Lines with InsertionPoint(module.body):
# CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction", "parallel"] # CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction", "parallel"]
# CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[FILTER:.+]]: f32, %[[OUT:.+]]: i32) # CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[FILTER:.+]]: f32, %[[OUT:.+]]: i32)
# CHECK-NEXT: %[[IN_CAST:.+]] = arith.fptosi %[[IN:.+]] : f32 to i32 # CHECK-NEXT: %[[IN_CAST:.+]] = arith.fptosi %[[IN:.+]] : f32 to i32
# CHECK-NEXT: %[[FILTER_CAST:.+]] = arith.fptosi %[[FILTER:.+]] : f32 to i32 # CHECK-NEXT: %[[FILTER_CAST:.+]] = arith.fptosi %[[FILTER:.+]] : f32 to i32
# CHECK-NEXT: %[[PROD:.+]] = arith.muli %[[IN_CAST]], %[[FILTER_CAST]] : i32 # CHECK-NEXT: %[[PROD:.+]] = arith.muli %[[IN_CAST]], %[[FILTER_CAST]] : i32
# CHECK-NEXT: %[[SUM:.+]] = arith.addi %[[OUT]], %[[PROD]] : i32 # CHECK-NEXT: %[[SUM:.+]] = arith.addi %[[OUT]], %[[PROD]] : i32
# CHECK-NEXT: linalg.yield %[[SUM]] : i32 # CHECK-NEXT: linalg.yield %[[SUM]] : i32
# CHECK-NEXT: -> tensor<1x2x4x1xi32> # CHECK-NEXT: -> tensor<1x2x4x1xi32>
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((1, 4, 16, 1), f32), RankedTensorType.get((1, 4, 16, 1), f32),
RankedTensorType.get((2, 2, 1), f32), RankedTensorType.get((2, 2, 1), f32),
RankedTensorType.get((1, 2, 4, 1), i32)) RankedTensorType.get((1, 2, 4, 1), i32))
def test_f32i32_conv(input, filter, init_result): def test_f32i32_conv(input, filter, init_result):
# Use default dilations and set non-default strides. # Use default dilations and set non-default strides.
return conv_poly( return conv_poly(
input, filter, outs=[init_result], strides=[2, 4]) input, filter, outs=[init_result], strides=[2, 4])
print(module) print(module)

mlir/test/python/dialects/linalg/opdsl/emit_fill.py

Show All 29 Lines with InsertionPoint(module.body):
# CHECK-DAG: #[[$MAP2:.+]] = affine_map<(d0, d1) -> (d0, d1)> # CHECK-DAG: #[[$MAP2:.+]] = affine_map<(d0, d1) -> (d0, d1)>
# CHECK-DAG: #[[$MAP3:.+]] = affine_map<(d0, d1, d2) -> ()> # CHECK-DAG: #[[$MAP3:.+]] = affine_map<(d0, d1, d2) -> ()>
# CHECK-DAG: #[[$MAP4:.+]] = affine_map<(d0, d1, d2) -> (d0, d1, d2)> # CHECK-DAG: #[[$MAP4:.+]] = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
# CHECK-LABEL: @test_fill_0d # CHECK-LABEL: @test_fill_0d
# CHECK: linalg.generic # CHECK: linalg.generic
# CHECK-SAME: indexing_maps = [#[[$MAP0]], #[[$MAP0]] # CHECK-SAME: indexing_maps = [#[[$MAP0]], #[[$MAP0]]
# CHECK-SAME: iterator_types = [] # CHECK-SAME: iterator_types = []
@builtin.FuncOp.from_py_func(f32, RankedTensorType.get([], f32)) @func.FuncOp.from_py_func(f32, RankedTensorType.get([], f32))
def test_fill_0d(value, init_result): def test_fill_0d(value, init_result):
return fill_poly(value, outs=[init_result]) return fill_poly(value, outs=[init_result])
# CHECK-LABEL: @test_fill_2d # CHECK-LABEL: @test_fill_2d
# CHECK: linalg.generic # CHECK: linalg.generic
# CHECK-SAME: indexing_maps = [#[[$MAP1]], #[[$MAP2]]] # CHECK-SAME: indexing_maps = [#[[$MAP1]], #[[$MAP2]]]
# CHECK-SAME: iterator_types = ["parallel", "parallel"] # CHECK-SAME: iterator_types = ["parallel", "parallel"]
@builtin.FuncOp.from_py_func(f32, RankedTensorType.get([4, 16], f32)) @func.FuncOp.from_py_func(f32, RankedTensorType.get([4, 16], f32))
def test_fill_2d(value, init_result): def test_fill_2d(value, init_result):
return fill_poly(value, outs=[init_result]) return fill_poly(value, outs=[init_result])
# CHECK-LABEL: @test_fill_rank_zero_3d # CHECK-LABEL: @test_fill_rank_zero_3d
# CHECK: linalg.generic # CHECK: linalg.generic
# CHECK-SAME: indexing_maps = [#[[$MAP3]], #[[$MAP4]]] # CHECK-SAME: indexing_maps = [#[[$MAP3]], #[[$MAP4]]]
# CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel"] # CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel"]
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get([], f32), RankedTensorType.get([4, 8, 16], f32)) RankedTensorType.get([], f32), RankedTensorType.get([4, 8, 16], f32))
def test_fill_rank_zero_3d(input, init_result): def test_fill_rank_zero_3d(input, init_result):
return fill_rank_zero_poly(input, outs=[init_result]) return fill_rank_zero_poly(input, outs=[init_result])
print(module) print(module)

mlir/test/python/dialects/linalg/opdsl/emit_matmul.py

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines with InsertionPoint(module.body):
# CHECK-SAME: %[[A:.+]]: tensor<4x16xf32> # CHECK-SAME: %[[A:.+]]: tensor<4x16xf32>
# CHECK-SAME: %[[B:.+]]: tensor<16x8xf32> # CHECK-SAME: %[[B:.+]]: tensor<16x8xf32>
# CHECK: %[[INITC:.+]] = linalg.init_tensor [4, 8] : tensor<4x8xf32> # CHECK: %[[INITC:.+]] = linalg.init_tensor [4, 8] : tensor<4x8xf32>
# CHECK: linalg.generic # CHECK: linalg.generic
# CHECK-SAME: indexing_maps = [#[[$MUL_MAP_A]], #[[$MUL_MAP_B]], #[[$MUL_MAP_C]]] # CHECK-SAME: indexing_maps = [#[[$MUL_MAP_A]], #[[$MUL_MAP_B]], #[[$MUL_MAP_C]]]
# CHECK-SAME: iterator_types = ["parallel", "parallel", "reduction"] # CHECK-SAME: iterator_types = ["parallel", "parallel", "reduction"]
# CHECK-SAME: ins(%[[A]], %[[B]] # CHECK-SAME: ins(%[[A]], %[[B]]
# CHECK-SAME: outs(%[[INITC]] # CHECK-SAME: outs(%[[INITC]]
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), f32), RankedTensorType.get((16, 8), f32)) RankedTensorType.get((4, 16), f32), RankedTensorType.get((16, 8), f32))
def test_matmul_mono(lhs, rhs): def test_matmul_mono(lhs, rhs):
init_result = linalg.InitTensorOp([4, 8], f32) init_result = linalg.InitTensorOp([4, 8], f32)
return matmul_mono(lhs, rhs, outs=[init_result.result]) return matmul_mono(lhs, rhs, outs=[init_result.result])
# CHECK-LABEL: @test_i8i8i32_matmul # CHECK-LABEL: @test_i8i8i32_matmul
# CHECK: ^{{.*}}(%[[A_ARG:.+]]: i8, %[[B_ARG:.+]]: i8, %[[C_ARG:.+]]: i32) # CHECK: ^{{.*}}(%[[A_ARG:.+]]: i8, %[[B_ARG:.+]]: i8, %[[C_ARG:.+]]: i32)
# CHECK-NEXT: %[[A_CAST:.+]] = arith.extsi %[[A_ARG]] : i8 to i32 # CHECK-NEXT: %[[A_CAST:.+]] = arith.extsi %[[A_ARG]] : i8 to i32
# CHECK-NEXT: %[[B_CAST:.+]] = arith.extsi %[[B_ARG]] : i8 to i32 # CHECK-NEXT: %[[B_CAST:.+]] = arith.extsi %[[B_ARG]] : i8 to i32
# CHECK-NEXT: %[[MUL:.+]] = arith.muli %[[A_CAST]], %[[B_CAST]] : i32 # CHECK-NEXT: %[[MUL:.+]] = arith.muli %[[A_CAST]], %[[B_CAST]] : i32
# CHECK-NEXT: %[[ADD:.+]] = arith.addi %[[C_ARG]], %[[MUL]] : i32 # CHECK-NEXT: %[[ADD:.+]] = arith.addi %[[C_ARG]], %[[MUL]] : i32
# CHECK-NEXT: linalg.yield %[[ADD]] : i32 # CHECK-NEXT: linalg.yield %[[ADD]] : i32
# CHECK-NEXT: -> tensor<4x8xi32> # CHECK-NEXT: -> tensor<4x8xi32>
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), i8), RankedTensorType.get((16, 8), i8), RankedTensorType.get((4, 16), i8), RankedTensorType.get((16, 8), i8),
RankedTensorType.get((4, 8), i32)) RankedTensorType.get((4, 8), i32))
def test_i8i8i32_matmul(lhs, rhs, init_result): def test_i8i8i32_matmul(lhs, rhs, init_result):
return matmul_poly(lhs, rhs, outs=[init_result]) return matmul_poly(lhs, rhs, outs=[init_result])
# CHECK-LABEL: @test_i8i8i32_matmul_unsigned # CHECK-LABEL: @test_i8i8i32_matmul_unsigned
# CHECK: = arith.extui # CHECK: = arith.extui
# CHECK: = arith.extui # CHECK: = arith.extui
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), i8), RankedTensorType.get((16, 8), i8), RankedTensorType.get((4, 16), i8), RankedTensorType.get((16, 8), i8),
RankedTensorType.get((4, 8), i32)) RankedTensorType.get((4, 8), i32))
def test_i8i8i32_matmul_unsigned(lhs, rhs, init_result): def test_i8i8i32_matmul_unsigned(lhs, rhs, init_result):
return matmul_poly( return matmul_poly(
lhs, rhs, outs=[init_result], cast=TypeFn.cast_unsigned) lhs, rhs, outs=[init_result], cast=TypeFn.cast_unsigned)
# CHECK-LABEL: @test_i8i16i32_matmul # CHECK-LABEL: @test_i8i16i32_matmul
# CHECK: ^{{.*}}(%[[A_ARG:.+]]: i8, %[[B_ARG:.+]]: i16, %[[C_ARG:.+]]: i32) # CHECK: ^{{.*}}(%[[A_ARG:.+]]: i8, %[[B_ARG:.+]]: i16, %[[C_ARG:.+]]: i32)
# CHECK-NEXT: %[[A_CAST:.+]] = arith.extsi %[[A_ARG]] : i8 to i32 # CHECK-NEXT: %[[A_CAST:.+]] = arith.extsi %[[A_ARG]] : i8 to i32
# CHECK-NEXT: %[[B_CAST:.+]] = arith.extsi %[[B_ARG]] : i16 to i32 # CHECK-NEXT: %[[B_CAST:.+]] = arith.extsi %[[B_ARG]] : i16 to i32
# CHECK-NEXT: %[[MUL:.+]] = arith.muli %[[A_CAST]], %[[B_CAST]] : i32 # CHECK-NEXT: %[[MUL:.+]] = arith.muli %[[A_CAST]], %[[B_CAST]] : i32
# CHECK-NEXT: %[[ADD:.+]] = arith.addi %[[C_ARG]], %[[MUL]] : i32 # CHECK-NEXT: %[[ADD:.+]] = arith.addi %[[C_ARG]], %[[MUL]] : i32
# CHECK-NEXT: linalg.yield %[[ADD]] : i32 # CHECK-NEXT: linalg.yield %[[ADD]] : i32
# CHECK-NEXT: -> tensor<4x8xi32> # CHECK-NEXT: -> tensor<4x8xi32>
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), i8), RankedTensorType.get((16, 8), i16), RankedTensorType.get((4, 16), i8), RankedTensorType.get((16, 8), i16),
RankedTensorType.get((4, 8), i32)) RankedTensorType.get((4, 8), i32))
def test_i8i16i32_matmul(lhs, rhs, init_result): def test_i8i16i32_matmul(lhs, rhs, init_result):
return matmul_poly(lhs, rhs, outs=[init_result]) return matmul_poly(lhs, rhs, outs=[init_result])
# CHECK-LABEL: @test_i32i32i16_matmul # CHECK-LABEL: @test_i32i32i16_matmul
# CHECK: ^{{.*}}(%[[A_ARG:.+]]: i32, %[[B_ARG:.+]]: i32, %[[C_ARG:.+]]: i16) # CHECK: ^{{.*}}(%[[A_ARG:.+]]: i32, %[[B_ARG:.+]]: i32, %[[C_ARG:.+]]: i16)
# CHECK-NEXT: %[[A_CAST:.+]] = arith.trunci %[[A_ARG]] : i32 to i16 # CHECK-NEXT: %[[A_CAST:.+]] = arith.trunci %[[A_ARG]] : i32 to i16
# CHECK-NEXT: %[[B_CAST:.+]] = arith.trunci %[[B_ARG]] : i32 to i16 # CHECK-NEXT: %[[B_CAST:.+]] = arith.trunci %[[B_ARG]] : i32 to i16
# CHECK-NEXT: %[[MUL:.+]] = arith.muli %[[A_CAST]], %[[B_CAST]] : i16 # CHECK-NEXT: %[[MUL:.+]] = arith.muli %[[A_CAST]], %[[B_CAST]] : i16
# CHECK-NEXT: %[[ADD:.+]] = arith.addi %[[C_ARG]], %[[MUL]] : i16 # CHECK-NEXT: %[[ADD:.+]] = arith.addi %[[C_ARG]], %[[MUL]] : i16
# CHECK-NEXT: linalg.yield %[[ADD]] : i16 # CHECK-NEXT: linalg.yield %[[ADD]] : i16
# CHECK-NEXT: -> tensor<4x8xi16> # CHECK-NEXT: -> tensor<4x8xi16>
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), i32), RankedTensorType.get((16, 8), i32), RankedTensorType.get((4, 16), i32), RankedTensorType.get((16, 8), i32),
RankedTensorType.get((4, 8), i16)) RankedTensorType.get((4, 8), i16))
def test_i32i32i16_matmul(lhs, rhs, init_result): def test_i32i32i16_matmul(lhs, rhs, init_result):
return matmul_poly(lhs, rhs, outs=[init_result]) return matmul_poly(lhs, rhs, outs=[init_result])
# CHECK-LABEL: @test_i8i8f32_matmul # CHECK-LABEL: @test_i8i8f32_matmul
# CHECK: ^{{.*}}(%[[A_ARG:.+]]: i8, %[[B_ARG:.+]]: i8, %[[C_ARG:.+]]: f32) # CHECK: ^{{.*}}(%[[A_ARG:.+]]: i8, %[[B_ARG:.+]]: i8, %[[C_ARG:.+]]: f32)
# CHECK-NEXT: %[[A_CAST:.+]] = arith.sitofp %[[A_ARG]] : i8 to f32 # CHECK-NEXT: %[[A_CAST:.+]] = arith.sitofp %[[A_ARG]] : i8 to f32
# CHECK-NEXT: %[[B_CAST:.+]] = arith.sitofp %[[B_ARG]] : i8 to f32 # CHECK-NEXT: %[[B_CAST:.+]] = arith.sitofp %[[B_ARG]] : i8 to f32
# CHECK-NEXT: %[[MUL:.+]] = arith.mulf %[[A_CAST]], %[[B_CAST]] : f32 # CHECK-NEXT: %[[MUL:.+]] = arith.mulf %[[A_CAST]], %[[B_CAST]] : f32
# CHECK-NEXT: %[[ADD:.+]] = arith.addf %[[C_ARG]], %[[MUL]] : f32 # CHECK-NEXT: %[[ADD:.+]] = arith.addf %[[C_ARG]], %[[MUL]] : f32
# CHECK-NEXT: linalg.yield %[[ADD]] : f32 # CHECK-NEXT: linalg.yield %[[ADD]] : f32
# CHECK-NEXT: -> tensor<4x8xf32> # CHECK-NEXT: -> tensor<4x8xf32>
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), i8), RankedTensorType.get((16, 8), i8), RankedTensorType.get((4, 16), i8), RankedTensorType.get((16, 8), i8),
RankedTensorType.get((4, 8), f32)) RankedTensorType.get((4, 8), f32))
def test_i8i8f32_matmul(lhs, rhs, init_result): def test_i8i8f32_matmul(lhs, rhs, init_result):
return matmul_poly(lhs, rhs, outs=[init_result]) return matmul_poly(lhs, rhs, outs=[init_result])
# CHECK-LABEL: @test_i8i8f32_matmul_unsigned # CHECK-LABEL: @test_i8i8f32_matmul_unsigned
# CHECK: = arith.uitofp # CHECK: = arith.uitofp
# CHECK: = arith.uitofp # CHECK: = arith.uitofp
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), i8), RankedTensorType.get((16, 8), i8), RankedTensorType.get((4, 16), i8), RankedTensorType.get((16, 8), i8),
RankedTensorType.get((4, 8), f32)) RankedTensorType.get((4, 8), f32))
def test_i8i8f32_matmul_unsigned(lhs, rhs, init_result): def test_i8i8f32_matmul_unsigned(lhs, rhs, init_result):
return matmul_poly( return matmul_poly(
lhs, rhs, outs=[init_result], cast=TypeFn.cast_unsigned) lhs, rhs, outs=[init_result], cast=TypeFn.cast_unsigned)
# CHECK-LABEL: @test_f16f16f32_matmul # CHECK-LABEL: @test_f16f16f32_matmul
# CHECK: ^{{.*}}(%[[A_ARG:.+]]: f16, %[[B_ARG:.+]]: f16, %[[C_ARG:.+]]: f32) # CHECK: ^{{.*}}(%[[A_ARG:.+]]: f16, %[[B_ARG:.+]]: f16, %[[C_ARG:.+]]: f32)
# CHECK-NEXT: %[[A_CAST:.+]] = arith.extf %[[A_ARG]] : f16 to f32 # CHECK-NEXT: %[[A_CAST:.+]] = arith.extf %[[A_ARG]] : f16 to f32
# CHECK-NEXT: %[[B_CAST:.+]] = arith.extf %[[B_ARG]] : f16 to f32 # CHECK-NEXT: %[[B_CAST:.+]] = arith.extf %[[B_ARG]] : f16 to f32
# CHECK-NEXT: %[[MUL:.+]] = arith.mulf %[[A_CAST]], %[[B_CAST]] : f32 # CHECK-NEXT: %[[MUL:.+]] = arith.mulf %[[A_CAST]], %[[B_CAST]] : f32
# CHECK-NEXT: %[[ADD:.+]] = arith.addf %[[C_ARG]], %[[MUL]] : f32 # CHECK-NEXT: %[[ADD:.+]] = arith.addf %[[C_ARG]], %[[MUL]] : f32
# CHECK-NEXT: linalg.yield %[[ADD]] : f32 # CHECK-NEXT: linalg.yield %[[ADD]] : f32
# CHECK-NEXT: -> tensor<4x8xf32> # CHECK-NEXT: -> tensor<4x8xf32>
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), f16), RankedTensorType.get((16, 8), f16), RankedTensorType.get((4, 16), f16), RankedTensorType.get((16, 8), f16),
RankedTensorType.get((4, 8), f32)) RankedTensorType.get((4, 8), f32))
def test_f16f16f32_matmul(lhs, rhs, init_result): def test_f16f16f32_matmul(lhs, rhs, init_result):
return matmul_poly(lhs, rhs, outs=[init_result]) return matmul_poly(lhs, rhs, outs=[init_result])
# CHECK-LABEL: @test_f64f64f32_matmul # CHECK-LABEL: @test_f64f64f32_matmul
# CHECK: ^{{.*}}(%[[A_ARG:.+]]: f64, %[[B_ARG:.+]]: f64, %[[C_ARG:.+]]: f32) # CHECK: ^{{.*}}(%[[A_ARG:.+]]: f64, %[[B_ARG:.+]]: f64, %[[C_ARG:.+]]: f32)
# CHECK-NEXT: %[[A_CAST:.+]] = arith.truncf %[[A_ARG]] : f64 to f32 # CHECK-NEXT: %[[A_CAST:.+]] = arith.truncf %[[A_ARG]] : f64 to f32
# CHECK-NEXT: %[[B_CAST:.+]] = arith.truncf %[[B_ARG]] : f64 to f32 # CHECK-NEXT: %[[B_CAST:.+]] = arith.truncf %[[B_ARG]] : f64 to f32
# CHECK-NEXT: %[[MUL:.+]] = arith.mulf %[[A_CAST]], %[[B_CAST]] : f32 # CHECK-NEXT: %[[MUL:.+]] = arith.mulf %[[A_CAST]], %[[B_CAST]] : f32
# CHECK-NEXT: %[[ADD:.+]] = arith.addf %[[C_ARG]], %[[MUL]] : f32 # CHECK-NEXT: %[[ADD:.+]] = arith.addf %[[C_ARG]], %[[MUL]] : f32
# CHECK-NEXT: linalg.yield %[[ADD]] : f32 # CHECK-NEXT: linalg.yield %[[ADD]] : f32
# CHECK-NEXT: -> tensor<4x8xf32> # CHECK-NEXT: -> tensor<4x8xf32>
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), f64), RankedTensorType.get((16, 8), f64), RankedTensorType.get((4, 16), f64), RankedTensorType.get((16, 8), f64),
RankedTensorType.get((4, 8), f32)) RankedTensorType.get((4, 8), f32))
def test_f64f64f32_matmul(lhs, rhs, init_result): def test_f64f64f32_matmul(lhs, rhs, init_result):
return matmul_poly(lhs, rhs, outs=[init_result]) return matmul_poly(lhs, rhs, outs=[init_result])
print(module) print(module)

mlir/test/python/dialects/linalg/opdsl/emit_misc.py

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines with InsertionPoint(module.body):
# CHECK-LABEL: @test_f32_const # CHECK-LABEL: @test_f32_const
# CHECK-DAG: %[[CST0:.+]] = arith.constant 42 : i64 # CHECK-DAG: %[[CST0:.+]] = arith.constant 42 : i64
# CHECK-DAG: %[[CST0_CAST:.+]] = arith.uitofp %[[CST0]] : i64 to f32 # CHECK-DAG: %[[CST0_CAST:.+]] = arith.uitofp %[[CST0]] : i64 to f32
# CHECK-DAG: %[[CST1:.+]] = arith.constant 2.3283063999999999E-10 : f64 # CHECK-DAG: %[[CST1:.+]] = arith.constant 2.3283063999999999E-10 : f64
# CHECK-DAG: %[[CST1_CAST:.+]] = arith.truncf %[[CST1]] : f64 to f32 # CHECK-DAG: %[[CST1_CAST:.+]] = arith.truncf %[[CST1]] : f64 to f32
# CHECK-DAG: %[[SUM:.+]] = arith.addf %[[CST0_CAST]], %[[CST1_CAST]] : f32 # CHECK-DAG: %[[SUM:.+]] = arith.addf %[[CST0_CAST]], %[[CST1_CAST]] : f32
# CHECK-NEXT: linalg.yield %[[SUM]] : f32 # CHECK-NEXT: linalg.yield %[[SUM]] : f32
@builtin.FuncOp.from_py_func(RankedTensorType.get((4, 16), f32)) @func.FuncOp.from_py_func(RankedTensorType.get((4, 16), f32))
def test_f32_const(init_result): def test_f32_const(init_result):
return test_const(outs=[init_result]) return test_const(outs=[init_result])
# CHECK-LABEL: @test_i32_index # CHECK-LABEL: @test_i32_index
# CHECK-DAG: %[[IDX0:.+]] = linalg.index 0 : index # CHECK-DAG: %[[IDX0:.+]] = linalg.index 0 : index
# CHECK-DAG: %[[IDX1:.+]] = linalg.index 1 : index # CHECK-DAG: %[[IDX1:.+]] = linalg.index 1 : index
# CHECK-DAG: %[[IDX0_CAST:.+]] = arith.index_cast %[[IDX0]] : index to i32 # CHECK-DAG: %[[IDX0_CAST:.+]] = arith.index_cast %[[IDX0]] : index to i32
# CHECK-DAG: %[[IDX1_CAST:.+]] = arith.index_cast %[[IDX1]] : index to i32 # CHECK-DAG: %[[IDX1_CAST:.+]] = arith.index_cast %[[IDX1]] : index to i32
# CHECK-DAG: %[[SUM:.+]] = arith.addi %[[IDX0_CAST]], %[[IDX1_CAST]] : i32 # CHECK-DAG: %[[SUM:.+]] = arith.addi %[[IDX0_CAST]], %[[IDX1_CAST]] : i32
# CHECK-NEXT: linalg.yield %[[SUM]] : i32 # CHECK-NEXT: linalg.yield %[[SUM]] : i32
@builtin.FuncOp.from_py_func(RankedTensorType.get((4, 16), i32)) @func.FuncOp.from_py_func(RankedTensorType.get((4, 16), i32))
def test_i32_index(init_result): def test_i32_index(init_result):
return test_index(outs=[init_result]) return test_index(outs=[init_result])
# CHECK-LABEL: @test_f32_elemwise_exp # CHECK-LABEL: @test_f32_elemwise_exp
# CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[OUT:.+]]: f32) # CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[OUT:.+]]: f32)
# CHECK-NEXT: %[[EXP:.+]] = math.exp %[[IN]] : f32 # CHECK-NEXT: %[[EXP:.+]] = math.exp %[[IN]] : f32
# CHECK-NEXT: linalg.yield %[[EXP]] : f32 # CHECK-NEXT: linalg.yield %[[EXP]] : f32
# CHECK-NEXT: -> tensor<4x16xf32> # CHECK-NEXT: -> tensor<4x16xf32>
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), f32), RankedTensorType.get((4, 16), f32)) RankedTensorType.get((4, 16), f32), RankedTensorType.get((4, 16), f32))
def test_f32_elemwise_exp(input, init_result): def test_f32_elemwise_exp(input, init_result):
return elemwise_unary_poly(input, outs=[init_result], fun=UnaryFn.exp) return elemwise_unary_poly(input, outs=[init_result], fun=UnaryFn.exp)
# CHECK-LABEL: @test_f32_elemwise_log # CHECK-LABEL: @test_f32_elemwise_log
# CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[OUT:.+]]: f32) # CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[OUT:.+]]: f32)
# CHECK-NEXT: %[[LOG:.+]] = math.log %[[IN]] : f32 # CHECK-NEXT: %[[LOG:.+]] = math.log %[[IN]] : f32
# CHECK-NEXT: linalg.yield %[[LOG]] : f32 # CHECK-NEXT: linalg.yield %[[LOG]] : f32
# CHECK-NEXT: -> tensor<4x16xf32> # CHECK-NEXT: -> tensor<4x16xf32>
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), f32), RankedTensorType.get((4, 16), f32)) RankedTensorType.get((4, 16), f32), RankedTensorType.get((4, 16), f32))
def test_f32_elemwise_log(input, init_result): def test_f32_elemwise_log(input, init_result):
return elemwise_unary_poly(input, outs=[init_result], fun=UnaryFn.log) return elemwise_unary_poly(input, outs=[init_result], fun=UnaryFn.log)
# CHECK-LABEL: @test_f32_elemwise_abs # CHECK-LABEL: @test_f32_elemwise_abs
# CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[OUT:.+]]: f32) # CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[OUT:.+]]: f32)
# CHECK-NEXT: %[[EXP:.+]] = math.abs %[[IN]] : f32 # CHECK-NEXT: %[[EXP:.+]] = math.abs %[[IN]] : f32
# CHECK-NEXT: linalg.yield %[[EXP]] : f32 # CHECK-NEXT: linalg.yield %[[EXP]] : f32
# CHECK-NEXT: -> tensor<4x16xf32> # CHECK-NEXT: -> tensor<4x16xf32>
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), f32), RankedTensorType.get((4, 16), f32)) RankedTensorType.get((4, 16), f32), RankedTensorType.get((4, 16), f32))
def test_f32_elemwise_abs(input, init_result): def test_f32_elemwise_abs(input, init_result):
return elemwise_unary_poly(input, outs=[init_result], fun=UnaryFn.abs) return elemwise_unary_poly(input, outs=[init_result], fun=UnaryFn.abs)
# CHECK-LABEL: @test_f32_elemwise_ceil # CHECK-LABEL: @test_f32_elemwise_ceil
# CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[OUT:.+]]: f32) # CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[OUT:.+]]: f32)
# CHECK-NEXT: %[[EXP:.+]] = math.ceil %[[IN]] : f32 # CHECK-NEXT: %[[EXP:.+]] = math.ceil %[[IN]] : f32
# CHECK-NEXT: linalg.yield %[[EXP]] : f32 # CHECK-NEXT: linalg.yield %[[EXP]] : f32
# CHECK-NEXT: -> tensor<4x16xf32> # CHECK-NEXT: -> tensor<4x16xf32>
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), f32), RankedTensorType.get((4, 16), f32)) RankedTensorType.get((4, 16), f32), RankedTensorType.get((4, 16), f32))
def test_f32_elemwise_ceil(input, init_result): def test_f32_elemwise_ceil(input, init_result):
return elemwise_unary_poly(input, outs=[init_result], fun=UnaryFn.ceil) return elemwise_unary_poly(input, outs=[init_result], fun=UnaryFn.ceil)
# CHECK-LABEL: @test_f32_elemwise_floor # CHECK-LABEL: @test_f32_elemwise_floor
# CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[OUT:.+]]: f32) # CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[OUT:.+]]: f32)
# CHECK-NEXT: %[[EXP:.+]] = math.floor %[[IN]] : f32 # CHECK-NEXT: %[[EXP:.+]] = math.floor %[[IN]] : f32
# CHECK-NEXT: linalg.yield %[[EXP]] : f32 # CHECK-NEXT: linalg.yield %[[EXP]] : f32
# CHECK-NEXT: -> tensor<4x16xf32> # CHECK-NEXT: -> tensor<4x16xf32>
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), f32), RankedTensorType.get((4, 16), f32)) RankedTensorType.get((4, 16), f32), RankedTensorType.get((4, 16), f32))
def test_f32_elemwise_floor(input, init_result): def test_f32_elemwise_floor(input, init_result):
return elemwise_unary_poly(input, outs=[init_result], fun=UnaryFn.floor) return elemwise_unary_poly(input, outs=[init_result], fun=UnaryFn.floor)
# CHECK-LABEL: @test_f32_elemwise_neg # CHECK-LABEL: @test_f32_elemwise_neg
# CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[OUT:.+]]: f32) # CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[OUT:.+]]: f32)
# CHECK-NEXT: %[[EXP:.+]] = arith.negf %[[IN]] : f32 # CHECK-NEXT: %[[EXP:.+]] = arith.negf %[[IN]] : f32
# CHECK-NEXT: linalg.yield %[[EXP]] : f32 # CHECK-NEXT: linalg.yield %[[EXP]] : f32
# CHECK-NEXT: -> tensor<4x16xf32> # CHECK-NEXT: -> tensor<4x16xf32>
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), f32), RankedTensorType.get((4, 16), f32)) RankedTensorType.get((4, 16), f32), RankedTensorType.get((4, 16), f32))
def test_f32_elemwise_neg(input, init_result): def test_f32_elemwise_neg(input, init_result):
return elemwise_unary_poly(input, outs=[init_result], fun=UnaryFn.negf) return elemwise_unary_poly(input, outs=[init_result], fun=UnaryFn.negf)
# Just check that we don't assert out on name mismatch. # Just check that we don't assert out on name mismatch.
# CHECK-LABEL: @test_non_default_op_name # CHECK-LABEL: @test_non_default_op_name
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((42,), f32), RankedTensorType.get((42,), f32)) RankedTensorType.get((42,), f32), RankedTensorType.get((42,), f32))
def test_non_default_op_name(input, init_result): def test_non_default_op_name(input, init_result):
return non_default_op_name(input, outs=[init_result]) return non_default_op_name(input, outs=[init_result])
print(module) print(module)

mlir/test/python/dialects/linalg/opdsl/emit_pooling.py

Show All 40 Lines with InsertionPoint(module.body):
# CHECK: linalg.generic # CHECK: linalg.generic
# CHECK-SAME: indexing_maps = [#[[$POOL_MAP_I]], #[[$POOL_MAP_K]], #[[$POOL_MAP_O]]] # CHECK-SAME: indexing_maps = [#[[$POOL_MAP_I]], #[[$POOL_MAP_K]], #[[$POOL_MAP_O]]]
# CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction", "parallel"] # CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction", "parallel"]
# CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[SHAPE:.+]]: f32, %[[OUT:.+]]: i32) # CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[SHAPE:.+]]: f32, %[[OUT:.+]]: i32)
# CHECK-NEXT: %[[IN_CAST:.+]] = arith.fptosi %[[IN:.+]] : f32 to i32 # CHECK-NEXT: %[[IN_CAST:.+]] = arith.fptosi %[[IN:.+]] : f32 to i32
# CHECK-NEXT: %[[MAX:.+]] = arith.maxsi %[[OUT]], %[[IN_CAST:.+]] : i32 # CHECK-NEXT: %[[MAX:.+]] = arith.maxsi %[[OUT]], %[[IN_CAST:.+]] : i32
# CHECK-NEXT: linalg.yield %[[MAX]] : i32 # CHECK-NEXT: linalg.yield %[[MAX]] : i32
# CHECK-NEXT: -> tensor<1x2x4x1xi32> # CHECK-NEXT: -> tensor<1x2x4x1xi32>
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((1, 4, 16, 1), f32), RankedTensorType.get((1, 4, 16, 1), f32),
RankedTensorType.get((2, 2), f32), RankedTensorType.get((2, 2), f32),
RankedTensorType.get((1, 2, 4, 1), i32)) RankedTensorType.get((1, 2, 4, 1), i32))
def test_f32i32_max_pooling(input, shape, init_result): def test_f32i32_max_pooling(input, shape, init_result):
return pooling_poly( return pooling_poly(
input, shape, outs=[init_result], strides=[2, 4], dilations=[1, 2]) input, shape, outs=[init_result], strides=[2, 4], dilations=[1, 2])
# CHECK-LABEL: @test_f32i32_max_unsigned_pooling # CHECK-LABEL: @test_f32i32_max_unsigned_pooling
# CHECK: = arith.fptoui # CHECK: = arith.fptoui
# CHECK: = arith.maxui # CHECK: = arith.maxui
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((1, 4, 16, 1), f32), RankedTensorType.get((1, 4, 16, 1), f32),
RankedTensorType.get((2, 2), f32), RankedTensorType.get((2, 2), f32),
RankedTensorType.get((1, 2, 4, 1), i32)) RankedTensorType.get((1, 2, 4, 1), i32))
def test_f32i32_max_unsigned_pooling(input, shape, init_result): def test_f32i32_max_unsigned_pooling(input, shape, init_result):
return pooling_poly( return pooling_poly(
input, input,
shape, shape,
outs=[init_result], outs=[init_result],
reduce=BinaryFn.max_unsigned, reduce=BinaryFn.max_unsigned,
cast=TypeFn.cast_unsigned, cast=TypeFn.cast_unsigned,
strides=[2, 4], strides=[2, 4],
dilations=[1, 2]) dilations=[1, 2])
# CHECK-LABEL: @test_f32f32_max_pooling # CHECK-LABEL: @test_f32f32_max_pooling
# CHECK: linalg.generic # CHECK: linalg.generic
# CHECK-SAME: indexing_maps = [#[[$POOL_MAP_I]], #[[$POOL_MAP_K]], #[[$POOL_MAP_O]]] # CHECK-SAME: indexing_maps = [#[[$POOL_MAP_I]], #[[$POOL_MAP_K]], #[[$POOL_MAP_O]]]
# CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction", "parallel"] # CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction", "parallel"]
# CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[SHAPE:.+]]: f32, %[[OUT:.+]]: f32) # CHECK: ^{{.*}}(%[[IN:.+]]: f32, %[[SHAPE:.+]]: f32, %[[OUT:.+]]: f32)
# CHECK-NEXT: %[[MAX:.+]] = arith.maxf %[[OUT]], %[[IN:.+]] : f32 # CHECK-NEXT: %[[MAX:.+]] = arith.maxf %[[OUT]], %[[IN:.+]] : f32
# CHECK-NEXT: linalg.yield %[[MAX]] : f32 # CHECK-NEXT: linalg.yield %[[MAX]] : f32
# CHECK-NEXT: -> tensor<1x2x4x1xf32> # CHECK-NEXT: -> tensor<1x2x4x1xf32>
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((1, 4, 16, 1), f32), RankedTensorType.get((1, 4, 16, 1), f32),
RankedTensorType.get((2, 2), f32), RankedTensorType.get((2, 2), f32),
RankedTensorType.get((1, 2, 4, 1), f32)) RankedTensorType.get((1, 2, 4, 1), f32))
def test_f32f32_max_pooling(input, shape, init_result): def test_f32f32_max_pooling(input, shape, init_result):
return pooling_poly( return pooling_poly(
input, shape, outs=[init_result], strides=[2, 4], dilations=[1, 2]) input, shape, outs=[init_result], strides=[2, 4], dilations=[1, 2])
# CHECK-LABEL: @test_f32i32_min_pooling # CHECK-LABEL: @test_f32i32_min_pooling
# CHECK: = arith.fptosi # CHECK: = arith.fptosi
# CHECK: = arith.minsi # CHECK: = arith.minsi
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((1, 4, 16, 1), f32), RankedTensorType.get((1, 4, 16, 1), f32),
RankedTensorType.get((2, 2), f32), RankedTensorType.get((2, 2), f32),
RankedTensorType.get((1, 2, 4, 1), i32)) RankedTensorType.get((1, 2, 4, 1), i32))
def test_f32i32_min_pooling(input, shape, init_result): def test_f32i32_min_pooling(input, shape, init_result):
return pooling_poly( return pooling_poly(
input, input,
shape, shape,
outs=[init_result], outs=[init_result],
reduce=BinaryFn.min_signed, reduce=BinaryFn.min_signed,
strides=[2, 4], strides=[2, 4],
dilations=[1, 2]) dilations=[1, 2])
# CHECK-LABEL: @test_f32i32_min_unsigned_pooling # CHECK-LABEL: @test_f32i32_min_unsigned_pooling
# CHECK: = arith.fptoui # CHECK: = arith.fptoui
# CHECK: = arith.minui # CHECK: = arith.minui
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((1, 4, 16, 1), f32), RankedTensorType.get((1, 4, 16, 1), f32),
RankedTensorType.get((2, 2), f32), RankedTensorType.get((2, 2), f32),
RankedTensorType.get((1, 2, 4, 1), i32)) RankedTensorType.get((1, 2, 4, 1), i32))
def test_f32i32_min_unsigned_pooling(input, shape, init_result): def test_f32i32_min_unsigned_pooling(input, shape, init_result):
return pooling_poly( return pooling_poly(
input, input,
shape, shape,
outs=[init_result], outs=[init_result],
reduce=BinaryFn.min_unsigned, reduce=BinaryFn.min_unsigned,
cast=TypeFn.cast_unsigned, cast=TypeFn.cast_unsigned,
strides=[2, 4], strides=[2, 4],
dilations=[1, 2]) dilations=[1, 2])
# CHECK-LABEL: @test_f32f32_min_pooling # CHECK-LABEL: @test_f32f32_min_pooling
# CHECK: = arith.minf # CHECK: = arith.minf
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((1, 4, 16, 1), f32), RankedTensorType.get((1, 4, 16, 1), f32),
RankedTensorType.get((2, 2), f32), RankedTensorType.get((2, 2), f32),
RankedTensorType.get((1, 2, 4, 1), f32)) RankedTensorType.get((1, 2, 4, 1), f32))
def test_f32f32_min_pooling(input, shape, init_result): def test_f32f32_min_pooling(input, shape, init_result):
return pooling_poly( return pooling_poly(
input, input,
shape, shape,
outs=[init_result], outs=[init_result],
reduce=BinaryFn.min_signed, reduce=BinaryFn.min_signed,
strides=[2, 4], strides=[2, 4],
dilations=[1, 2]) dilations=[1, 2])
print(module) print(module)

mlir/test/python/dialects/linalg/ops.py

Show All 18 Lines
@run @run
def testInitTensor(): def testInitTensor():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
with InsertionPoint(module.body): with InsertionPoint(module.body):
# CHECK-LABEL: func @static_sizes # CHECK-LABEL: func @static_sizes
# CHECK: %0 = linalg.init_tensor [3, 4] : tensor<3x4xf32> # CHECK: %0 = linalg.init_tensor [3, 4] : tensor<3x4xf32>
@builtin.FuncOp.from_py_func() @func.FuncOp.from_py_func()
def static_sizes(): def static_sizes():
return linalg.InitTensorOp([3, 4], f32) return linalg.InitTensorOp([3, 4], f32)
# CHECK-LABEL: func @dynamic_sizes # CHECK-LABEL: func @dynamic_sizes
# CHECK: %0 = linalg.init_tensor [%arg0, %arg1] : tensor<?x?xf32> # CHECK: %0 = linalg.init_tensor [%arg0, %arg1] : tensor<?x?xf32>
@builtin.FuncOp.from_py_func(IndexType.get(), IndexType.get()) @func.FuncOp.from_py_func(IndexType.get(), IndexType.get())
def dynamic_sizes(d0, d1): def dynamic_sizes(d0, d1):
return linalg.InitTensorOp([d0, d1], f32) return linalg.InitTensorOp([d0, d1], f32)
# CHECK-LABEL: func @zero_d # CHECK-LABEL: func @zero_d
# CHECK: %0 = linalg.init_tensor [] : tensor<f32> # CHECK: %0 = linalg.init_tensor [] : tensor<f32>
@builtin.FuncOp.from_py_func() @func.FuncOp.from_py_func()
def zero_d(): def zero_d():
return linalg.InitTensorOp([], f32) return linalg.InitTensorOp([], f32)
print(module) print(module)
# CHECK-LABEL: TEST: testInitTensorStaticSizesAttribute # CHECK-LABEL: TEST: testInitTensorStaticSizesAttribute
@run @run
Show All 14 Lines with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
with InsertionPoint(module.body): with InsertionPoint(module.body):
# CHECK-LABEL: func @fill_tensor # CHECK-LABEL: func @fill_tensor
# CHECK-SAME: %[[OUT:[0-9a-z]+]]: tensor<12x?xf32> # CHECK-SAME: %[[OUT:[0-9a-z]+]]: tensor<12x?xf32>
# CHECK-NEXT: %[[CST:.*]] = arith.constant 0.0{{.*}} : f32 # CHECK-NEXT: %[[CST:.*]] = arith.constant 0.0{{.*}} : f32
# CHECK-NEXT: %[[RES:.*]] = linalg.fill ins(%[[CST]] : f32) outs(%[[OUT]] : tensor<12x?xf32>) -> tensor<12x?xf32> # CHECK-NEXT: %[[RES:.*]] = linalg.fill ins(%[[CST]] : f32) outs(%[[OUT]] : tensor<12x?xf32>) -> tensor<12x?xf32>
# CHECK-NEXT: return %[[RES]] : tensor<12x?xf32> # CHECK-NEXT: return %[[RES]] : tensor<12x?xf32>
@builtin.FuncOp.from_py_func(RankedTensorType.get((12, -1), f32)) @func.FuncOp.from_py_func(RankedTensorType.get((12, -1), f32))
def fill_tensor(out): def fill_tensor(out):
zero = arith.ConstantOp(value=FloatAttr.get(f32, 0.), result=f32).result zero = arith.ConstantOp(value=FloatAttr.get(f32, 0.), result=f32).result
return linalg.fill(zero, outs=[out]) return linalg.fill(zero, outs=[out])
# CHECK-LABEL: func @fill_buffer # CHECK-LABEL: func @fill_buffer
# CHECK-SAME: %[[OUT:[0-9a-z]+]]: memref<12x?xf32> # CHECK-SAME: %[[OUT:[0-9a-z]+]]: memref<12x?xf32>
# CHECK-NEXT: %[[CST:.*]] = arith.constant 0.0{{.*}} : f32 # CHECK-NEXT: %[[CST:.*]] = arith.constant 0.0{{.*}} : f32
# CHECK-NEXT: linalg.fill ins(%[[CST]] : f32) outs(%[[OUT]] : memref<12x?xf32>) # CHECK-NEXT: linalg.fill ins(%[[CST]] : f32) outs(%[[OUT]] : memref<12x?xf32>)
# CHECK-NEXT: return # CHECK-NEXT: return
@builtin.FuncOp.from_py_func(MemRefType.get((12, -1), f32)) @func.FuncOp.from_py_func(MemRefType.get((12, -1), f32))
def fill_buffer(out): def fill_buffer(out):
zero = arith.ConstantOp(value=FloatAttr.get(f32, 0.), result=f32).result zero = arith.ConstantOp(value=FloatAttr.get(f32, 0.), result=f32).result
linalg.fill(zero, outs=[out]) linalg.fill(zero, outs=[out])
print(module) print(module)
# CHECK-LABEL: TEST: testNamedStructuredOpCustomForm # CHECK-LABEL: TEST: testNamedStructuredOpCustomForm
@run @run
def testNamedStructuredOpCustomForm(): def testNamedStructuredOpCustomForm():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 8), f32), RankedTensorType.get((4, 8), f32)) RankedTensorType.get((4, 8), f32), RankedTensorType.get((4, 8), f32))
def named_form(lhs, rhs): def named_form(lhs, rhs):
init_result = linalg.InitTensorOp([4, 8], f32) init_result = linalg.InitTensorOp([4, 8], f32)
# Check for the named form with custom format # Check for the named form with custom format
# CHECK: linalg.elemwise_unary # CHECK: linalg.elemwise_unary
# CHECK-SAME: cast = #linalg.type_fn<cast_signed> # CHECK-SAME: cast = #linalg.type_fn<cast_signed>
# CHECK-SAME: fun = #linalg.unary_fn<exp> # CHECK-SAME: fun = #linalg.unary_fn<exp>
# CHECK-SAME: ins(%{{.*}} : tensor<4x8xf32>) outs(%{{.*}} : tensor<4x8xf32>) # CHECK-SAME: ins(%{{.*}} : tensor<4x8xf32>) outs(%{{.*}} : tensor<4x8xf32>)
Show All 17 Lines
# CHECK-LABEL: TEST: testNamedStructuredOpGenericForm # CHECK-LABEL: TEST: testNamedStructuredOpGenericForm
@run @run
def testNamedStructuredOpGenericForm(): def testNamedStructuredOpGenericForm():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), f32), RankedTensorType.get((16, 8), RankedTensorType.get((4, 16), f32), RankedTensorType.get((16, 8),
f32)) f32))
def named_form(lhs, rhs): def named_form(lhs, rhs):
init_result = linalg.InitTensorOp([4, 8], f32) init_result = linalg.InitTensorOp([4, 8], f32)
# CHECK: "linalg.matmul"(%{{.*}}) # CHECK: "linalg.matmul"(%{{.*}})
# CHECK-NEXT: ^bb0(%{{.*}}: f32, %{{.*}}: f32, %{{.*}}: f32): # CHECK-NEXT: ^bb0(%{{.*}}: f32, %{{.*}}: f32, %{{.*}}: f32):
# CHECK-NEXT: arith.mulf{{.*}} (f32, f32) -> f32 # CHECK-NEXT: arith.mulf{{.*}} (f32, f32) -> f32
# CHECK-NEXT: arith.addf{{.*}} (f32, f32) -> f32 # CHECK-NEXT: arith.addf{{.*}} (f32, f32) -> f32
Show All 9 Lines
# CHECK-LABEL: TEST: testNamedStructuredAsGenericOp # CHECK-LABEL: TEST: testNamedStructuredAsGenericOp
@run @run
def testNamedStructuredAsGenericOp(): def testNamedStructuredAsGenericOp():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), f32), RankedTensorType.get((16, 8), RankedTensorType.get((4, 16), f32), RankedTensorType.get((16, 8),
f32)) f32))
def generic_form(lhs, rhs): def generic_form(lhs, rhs):
init_result = linalg.InitTensorOp([4, 8], f32) init_result = linalg.InitTensorOp([4, 8], f32)
# CHECK: linalg.generic # CHECK: linalg.generic
return linalg.matmul( return linalg.matmul(
lhs, rhs, outs=[init_result.result], emit_generic=True) lhs, rhs, outs=[init_result.result], emit_generic=True)
print(module) print(module)
# CHECK-LABEL: TEST: testOpResultFromOtherOp # CHECK-LABEL: TEST: testOpResultFromOtherOp
@run @run
def testOpResultFromOtherOp(): def testOpResultFromOtherOp():
with Context(), Location.unknown(): with Context(), Location.unknown():
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((4, 16), f32), RankedTensorType.get((16, 8), RankedTensorType.get((4, 16), f32), RankedTensorType.get((16, 8),
f32)) f32))
def pass_an_op_directly(arg0, arg1): def pass_an_op_directly(arg0, arg1):
one = arith.ConstantOp(F32Type.get(), 1.0) one = arith.ConstantOp(F32Type.get(), 1.0)
# CHECK: %[[LHS:.*]] = linalg.fill # CHECK: %[[LHS:.*]] = linalg.fill
lhs = linalg.fill(one, outs=[arg0]) lhs = linalg.fill(one, outs=[arg0])
# CHECK: %[[RHS:.*]] = linalg.fill # CHECK: %[[RHS:.*]] = linalg.fill
rhs = linalg.fill(one, outs=[arg1]) rhs = linalg.fill(one, outs=[arg1])
# CHECK: %[[INIT:.*]] = linalg.init_tensor # CHECK: %[[INIT:.*]] = linalg.init_tensor
init = linalg.InitTensorOp([4, 8], f32) init = linalg.InitTensorOp([4, 8], f32)
# CHECK: linalg.matmul # CHECK: linalg.matmul
# CHECK: ins(%[[LHS]], %[[RHS]] # CHECK: ins(%[[LHS]], %[[RHS]]
# CHECK: outs(%[[INIT]] # CHECK: outs(%[[INIT]]
return linalg.matmul(lhs, rhs, outs=init) return linalg.matmul(lhs, rhs, outs=init)
print(module) print(module)

mlir/test/python/dialects/math_dialect.py

# RUN: %PYTHON %s | FileCheck %s # RUN: %PYTHON %s | FileCheck %s
# Naming this file with a `_dialect` suffix to avoid a naming conflict with # Naming this file with a `_dialect` suffix to avoid a naming conflict with
# python package's math module (coming in from random.py). # python package's math module (coming in from random.py).
from mlir.ir import * from mlir.ir import *
import mlir.dialects.builtin as builtin import mlir.dialects.func as func
import mlir.dialects.math as mlir_math import mlir.dialects.math as mlir_math
def run(f): def run(f):
print("\nTEST:", f.__name__) print("\nTEST:", f.__name__)
f() f()
# CHECK-LABEL: TEST: testMathOps # CHECK-LABEL: TEST: testMathOps
@run @run
def testMathOps(): def testMathOps():
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):
@builtin.FuncOp.from_py_func(F32Type.get()) @func.FuncOp.from_py_func(F32Type.get())
def emit_sqrt(arg): def emit_sqrt(arg):
return mlir_math.SqrtOp(arg) return mlir_math.SqrtOp(arg)
# CHECK-LABEL: func @emit_sqrt( # CHECK-LABEL: func @emit_sqrt(
# CHECK-SAME: %[[ARG:.*]]: f32) -> f32 { # CHECK-SAME: %[[ARG:.*]]: f32) -> f32 {
# CHECK: math.sqrt %[[ARG]] : f32 # CHECK: math.sqrt %[[ARG]] : f32
# CHECK: return # CHECK: return
# CHECK: } # CHECK: }
print(module) print(module)

mlir/test/python/dialects/scf.py

Show All 16 Linesdef constructAndPrintInModule(f):
return f return f
# CHECK-LABEL: TEST: testSimpleLoop # CHECK-LABEL: TEST: testSimpleLoop
@constructAndPrintInModule @constructAndPrintInModule
def testSimpleLoop(): def testSimpleLoop():
index_type = IndexType.get() index_type = IndexType.get()
@builtin.FuncOp.from_py_func(index_type, index_type, index_type) @func.FuncOp.from_py_func(index_type, index_type, index_type)
def simple_loop(lb, ub, step): def simple_loop(lb, ub, step):
loop = scf.ForOp(lb, ub, step, [lb, lb]) loop = scf.ForOp(lb, ub, step, [lb, lb])
with InsertionPoint(loop.body): with InsertionPoint(loop.body):
scf.YieldOp(loop.inner_iter_args) scf.YieldOp(loop.inner_iter_args)
return return
# CHECK: func @simple_loop(%[[ARG0:.*]]: index, %[[ARG1:.*]]: index, %[[ARG2:.*]]: index) # CHECK: func @simple_loop(%[[ARG0:.*]]: index, %[[ARG1:.*]]: index, %[[ARG2:.*]]: index)
# CHECK: scf.for %{{.*}} = %[[ARG0]] to %[[ARG1]] step %[[ARG2]] # CHECK: scf.for %{{.*}} = %[[ARG0]] to %[[ARG1]] step %[[ARG2]]
# CHECK: iter_args(%[[I1:.*]] = %[[ARG0]], %[[I2:.*]] = %[[ARG0]]) # CHECK: iter_args(%[[I1:.*]] = %[[ARG0]], %[[I2:.*]] = %[[ARG0]])
# CHECK: scf.yield %[[I1]], %[[I2]] # CHECK: scf.yield %[[I1]], %[[I2]]
# CHECK-LABEL: TEST: testInductionVar # CHECK-LABEL: TEST: testInductionVar
@constructAndPrintInModule @constructAndPrintInModule
def testInductionVar(): def testInductionVar():
index_type = IndexType.get() index_type = IndexType.get()
@builtin.FuncOp.from_py_func(index_type, index_type, index_type) @func.FuncOp.from_py_func(index_type, index_type, index_type)
def induction_var(lb, ub, step): def induction_var(lb, ub, step):
loop = scf.ForOp(lb, ub, step, [lb]) loop = scf.ForOp(lb, ub, step, [lb])
with InsertionPoint(loop.body): with InsertionPoint(loop.body):
scf.YieldOp([loop.induction_variable]) scf.YieldOp([loop.induction_variable])
return return
# CHECK: func @induction_var(%[[ARG0:.*]]: index, %[[ARG1:.*]]: index, %[[ARG2:.*]]: index) # CHECK: func @induction_var(%[[ARG0:.*]]: index, %[[ARG1:.*]]: index, %[[ARG2:.*]]: index)
# CHECK: scf.for %[[IV:.*]] = %[[ARG0]] to %[[ARG1]] step %[[ARG2]] # CHECK: scf.for %[[IV:.*]] = %[[ARG0]] to %[[ARG1]] step %[[ARG2]]
# CHECK: scf.yield %[[IV]] # CHECK: scf.yield %[[IV]]
@constructAndPrintInModule @constructAndPrintInModule
def testOpsAsArguments(): def testOpsAsArguments():
index_type = IndexType.get() index_type = IndexType.get()
callee = builtin.FuncOp( callee = func.FuncOp(
"callee", ([], [index_type, index_type]), visibility="private") "callee", ([], [index_type, index_type]), visibility="private")
f = builtin.FuncOp("ops_as_arguments", ([], [])) f = func.FuncOp("ops_as_arguments", ([], []))
with InsertionPoint(f.add_entry_block()): with InsertionPoint(f.add_entry_block()):
lb = arith.ConstantOp.create_index(0) lb = arith.ConstantOp.create_index(0)
ub = arith.ConstantOp.create_index(42) ub = arith.ConstantOp.create_index(42)
step = arith.ConstantOp.create_index(2) step = arith.ConstantOp.create_index(2)
iter_args = func.CallOp(callee, []) iter_args = func.CallOp(callee, [])
loop = scf.ForOp(lb, ub, step, iter_args) loop = scf.ForOp(lb, ub, step, iter_args)
with InsertionPoint(loop.body): with InsertionPoint(loop.body):
scf.YieldOp(loop.inner_iter_args) scf.YieldOp(loop.inner_iter_args)
Show All 13 Lines
# CHECK: return # CHECK: return
@constructAndPrintInModule @constructAndPrintInModule
def testIfWithoutElse(): def testIfWithoutElse():
bool = IntegerType.get_signless(1) bool = IntegerType.get_signless(1)
i32 = IntegerType.get_signless(32) i32 = IntegerType.get_signless(32)
@builtin.FuncOp.from_py_func(bool) @func.FuncOp.from_py_func(bool)
def simple_if(cond): def simple_if(cond):
if_op = scf.IfOp(cond) if_op = scf.IfOp(cond)
with InsertionPoint(if_op.then_block): with InsertionPoint(if_op.then_block):
one = arith.ConstantOp(i32, 1) one = arith.ConstantOp(i32, 1)
add = arith.AddIOp(one, one) add = arith.AddIOp(one, one)
scf.YieldOp([]) scf.YieldOp([])
return return
# CHECK: func @simple_if(%[[ARG0:.*]]: i1) # CHECK: func @simple_if(%[[ARG0:.*]]: i1)
# CHECK: scf.if %[[ARG0:.*]] # CHECK: scf.if %[[ARG0:.*]]
# CHECK: %[[ONE:.*]] = arith.constant 1 # CHECK: %[[ONE:.*]] = arith.constant 1
# CHECK: %[[ADD:.*]] = arith.addi %[[ONE]], %[[ONE]] # CHECK: %[[ADD:.*]] = arith.addi %[[ONE]], %[[ONE]]
# CHECK: return # CHECK: return
@constructAndPrintInModule @constructAndPrintInModule
def testIfWithElse(): def testIfWithElse():
bool = IntegerType.get_signless(1) bool = IntegerType.get_signless(1)
i32 = IntegerType.get_signless(32) i32 = IntegerType.get_signless(32)
@builtin.FuncOp.from_py_func(bool) @func.FuncOp.from_py_func(bool)
def simple_if_else(cond): def simple_if_else(cond):
if_op = scf.IfOp(cond, [i32, i32], hasElse=True) if_op = scf.IfOp(cond, [i32, i32], hasElse=True)
with InsertionPoint(if_op.then_block): with InsertionPoint(if_op.then_block):
x_true = arith.ConstantOp(i32, 0) x_true = arith.ConstantOp(i32, 0)
y_true = arith.ConstantOp(i32, 1) y_true = arith.ConstantOp(i32, 1)
scf.YieldOp([x_true, y_true]) scf.YieldOp([x_true, y_true])
with InsertionPoint(if_op.else_block): with InsertionPoint(if_op.else_block):
x_false = arith.ConstantOp(i32, 2) x_false = arith.ConstantOp(i32, 2)
Show All 17 Lines

mlir/test/python/dialects/shape.py

# RUN: %PYTHON %s | FileCheck %s # RUN: %PYTHON %s | FileCheck %s
from mlir.ir import * from mlir.ir import *
import numpy as np import numpy as np
import mlir.dialects.builtin as builtin import mlir.dialects.func as func
import mlir.dialects.shape as shape import mlir.dialects.shape as shape
def run(f): def run(f):
print("\nTEST:", f.__name__) print("\nTEST:", f.__name__)
f() f()
return f return f
# CHECK-LABEL: TEST: testConstShape # CHECK-LABEL: TEST: testConstShape
@run @run
def testConstShape(): def testConstShape():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
RankedTensorType.get((12, -1), f32)) RankedTensorType.get((12, -1), f32))
def const_shape_tensor(arg): def const_shape_tensor(arg):
return shape.ConstShapeOp( return shape.ConstShapeOp(
DenseElementsAttr.get(np.array([10, 20]), type=IndexType.get())) DenseElementsAttr.get(np.array([10, 20]), type=IndexType.get()))
# CHECK-LABEL: func @const_shape_tensor(%arg0: tensor<12x?xf32>) # CHECK-LABEL: func @const_shape_tensor(%arg0: tensor<12x?xf32>)
# CHECK: shape.const_shape [10, 20] : tensor<2xindex> # CHECK: shape.const_shape [10, 20] : tensor<2xindex>
print(module) print(module)

mlir/test/python/dialects/tensor.py

# RUN: %PYTHON %s | FileCheck %s # RUN: %PYTHON %s | FileCheck %s
from mlir.ir import * from mlir.ir import *
import mlir.dialects.arith as arith import mlir.dialects.arith as arith
import mlir.dialects.builtin as builtin import mlir.dialects.func as func
import mlir.dialects.tensor as tensor import mlir.dialects.tensor as tensor
def run(f): def run(f):
print("\nTEST:", f.__name__) print("\nTEST:", f.__name__)
f() f()
return f return f
# CHECK-LABEL: TEST: testDimOp # CHECK-LABEL: TEST: testDimOp
@run @run
def testDimOp(): def testDimOp():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f32Type = F32Type.get() f32Type = F32Type.get()
indexType = IndexType.get() indexType = IndexType.get()
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func(RankedTensorType.get((-1, -1), f32Type)) @func.FuncOp.from_py_func(RankedTensorType.get((-1, -1), f32Type))
# CHECK: func @tensor_static_dim # CHECK: func @tensor_static_dim
# CHECK-SAME: %[[ARG0:.+]]: tensor<?x?xf32> # CHECK-SAME: %[[ARG0:.+]]: tensor<?x?xf32>
# CHECK-DAG: %[[C0:.+]] = arith.constant 0 : index # CHECK-DAG: %[[C0:.+]] = arith.constant 0 : index
# CHECK-DAG: %[[C1:.+]] = arith.constant 1 : index # CHECK-DAG: %[[C1:.+]] = arith.constant 1 : index
# CHECK: %[[D0:.+]] = tensor.dim %[[ARG0]], %[[C0]] # CHECK: %[[D0:.+]] = tensor.dim %[[ARG0]], %[[C0]]
# CHECK: %[[D1:.+]] = tensor.dim %[[ARG0]], %[[C1]] # CHECK: %[[D1:.+]] = tensor.dim %[[ARG0]], %[[C1]]
# CHECK: return %[[D0]], %[[D1]] # CHECK: return %[[D0]], %[[D1]]
def tensor_static_dim(t): def tensor_static_dim(t):
c0 = arith.ConstantOp(indexType, 0) c0 = arith.ConstantOp(indexType, 0)
c1 = arith.ConstantOp(indexType, 1) c1 = arith.ConstantOp(indexType, 1)
d0 = tensor.DimOp(t, c0) d0 = tensor.DimOp(t, c0)
d1 = tensor.DimOp(t, c1) d1 = tensor.DimOp(t, c1)
return [d0.result, d1.result] return [d0.result, d1.result]
print(module) print(module)

mlir/test/python/dialects/vector.py

Show All 11 Linesdef run(f):
return f return f
# CHECK-LABEL: TEST: testPrintOp # CHECK-LABEL: TEST: testPrintOp
@run @run
def testPrintOp(): def testPrintOp():
module = Module.create() module = Module.create()
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func(VectorType.get((12, 5), F32Type.get())) @func.FuncOp.from_py_func(VectorType.get((12, 5), F32Type.get()))
def print_vector(arg): def print_vector(arg):
return vector.PrintOp(arg) return vector.PrintOp(arg)
# CHECK-LABEL: func @print_vector( # CHECK-LABEL: func @print_vector(
# CHECK-SAME: %[[ARG:.*]]: vector<12x5xf32>) { # CHECK-SAME: %[[ARG:.*]]: vector<12x5xf32>) {
# CHECK: vector.print %[[ARG]] : vector<12x5xf32> # CHECK: vector.print %[[ARG]] : vector<12x5xf32>
# CHECK: return # CHECK: return
# CHECK: } # CHECK: }
print(module) print(module)
# CHECK-LABEL: TEST: testTransferReadOp # CHECK-LABEL: TEST: testTransferReadOp
@run @run
def testTransferReadOp(): def testTransferReadOp():
module = Module.create() module = Module.create()
with InsertionPoint(module.body): with InsertionPoint(module.body):
vector_type = VectorType.get([2, 3], F32Type.get()) vector_type = VectorType.get([2, 3], F32Type.get())
memref_type = MemRefType.get([-1, -1], F32Type.get()) memref_type = MemRefType.get([-1, -1], F32Type.get())
index_type = IndexType.get() index_type = IndexType.get()
mask_type = VectorType.get(vector_type.shape, IntegerType.get_signless(1)) mask_type = VectorType.get(vector_type.shape, IntegerType.get_signless(1))
identity_map = AffineMap.get_identity(vector_type.rank) identity_map = AffineMap.get_identity(vector_type.rank)
identity_map_attr = AffineMapAttr.get(identity_map) identity_map_attr = AffineMapAttr.get(identity_map)
f = builtin.FuncOp("transfer_read", f = func.FuncOp("transfer_read",
([memref_type, index_type, ([memref_type, index_type,
F32Type.get(), mask_type], [])) F32Type.get(), mask_type], []))
with InsertionPoint(f.add_entry_block()): with InsertionPoint(f.add_entry_block()):
A, zero, padding, mask = f.arguments A, zero, padding, mask = f.arguments
vector.TransferReadOp(vector_type, A, [zero, zero], identity_map_attr, vector.TransferReadOp(vector_type, A, [zero, zero], identity_map_attr,
padding, mask, None) padding, mask, None)
vector.TransferReadOp(vector_type, A, [zero, zero], identity_map_attr, vector.TransferReadOp(vector_type, A, [zero, zero], identity_map_attr,
padding, None, None) padding, None, None)
func.ReturnOp([]) func.ReturnOp([])
# CHECK: @transfer_read(%[[MEM:.*]]: memref<?x?xf32>, %[[IDX:.*]]: index, # CHECK: @transfer_read(%[[MEM:.*]]: memref<?x?xf32>, %[[IDX:.*]]: index,
# CHECK: %[[PAD:.*]]: f32, %[[MASK:.*]]: vector<2x3xi1>) # CHECK: %[[PAD:.*]]: f32, %[[MASK:.*]]: vector<2x3xi1>)
# CHECK: vector.transfer_read %[[MEM]][%[[IDX]], %[[IDX]]], %[[PAD]], %[[MASK]] # CHECK: vector.transfer_read %[[MEM]][%[[IDX]], %[[IDX]]], %[[PAD]], %[[MASK]]
# CHECK: vector.transfer_read %[[MEM]][%[[IDX]], %[[IDX]]], %[[PAD]] # CHECK: vector.transfer_read %[[MEM]][%[[IDX]], %[[IDX]]], %[[PAD]]
# CHECK-NOT: %[[MASK]] # CHECK-NOT: %[[MASK]]
print(module) print(module)

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

Show First 20 Lines • Show All 190 Lines • ▼ Show 20 Linesdef transform(module, boilerplate):
import mlir.transforms import mlir.transforms
# 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.
ops = module.operation.regions[0].blocks[0].operations ops = module.operation.regions[0].blocks[0].operations
mod = Module.parse("\n".join([str(op) for op in ops]) + boilerplate) mod = Module.parse("\n".join([str(op) for op in ops]) + boilerplate)
pm = PassManager.parse( pm = PassManager.parse(
"builtin.func(convert-linalg-to-loops, lower-affine, " + "func.func(convert-linalg-to-loops, lower-affine, " +
"convert-math-to-llvm, convert-scf-to-cf, arith-expand, memref-expand), " "convert-math-to-llvm, convert-scf-to-cf, arith-expand, memref-expand), "
+ "convert-vector-to-llvm, convert-memref-to-llvm, convert-func-to-llvm," + + "convert-vector-to-llvm, convert-memref-to-llvm, convert-func-to-llvm," +
"reconcile-unrealized-casts") "reconcile-unrealized-casts")
pm.run(mod) pm.run(mod)
return mod return mod
def test_elemwise_builtin(): def test_elemwise_builtin():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
i8 = IntegerType.get_signless(8) i8 = IntegerType.get_signless(8)
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
MemRefType.get((), f32), MemRefType.get((4, 8), f32), MemRefType.get((), f32), MemRefType.get((4, 8), f32),
MemRefType.get((4, 8), f32)) MemRefType.get((4, 8), f32))
def elemwise_exp_add_on_buffers(lhs, rhs, out): def elemwise_exp_add_on_buffers(lhs, rhs, out):
linalg.elemwise_unary(lhs, outs=[out]) linalg.elemwise_unary(lhs, outs=[out])
linalg.elemwise_binary(out, rhs, outs=[out]) linalg.elemwise_binary(out, rhs, outs=[out])
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
MemRefType.get((), f32), MemRefType.get((4, 8), f32), MemRefType.get((), f32), MemRefType.get((4, 8), f32),
MemRefType.get((4, 8), f32)) MemRefType.get((4, 8), f32))
def elemwise_log_mul_on_buffers(lhs, rhs, out): def elemwise_log_mul_on_buffers(lhs, rhs, out):
linalg.elemwise_unary(lhs, outs=[out], fun=UnaryFn.log) linalg.elemwise_unary(lhs, outs=[out], fun=UnaryFn.log)
linalg.elemwise_binary(out, rhs, outs=[out], fun=BinaryFn.mul) linalg.elemwise_binary(out, rhs, outs=[out], fun=BinaryFn.mul)
execution_engine = ExecutionEngine(transform(module, elemwise_boiler)) execution_engine = ExecutionEngine(transform(module, elemwise_boiler))
Show All 15 Lines
def test_elemwise_generic(): def test_elemwise_generic():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
i8 = IntegerType.get_signless(8) i8 = IntegerType.get_signless(8)
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
MemRefType.get((), f32), MemRefType.get((4, 8), f32), MemRefType.get((), f32), MemRefType.get((4, 8), f32),
MemRefType.get((4, 8), f32)) MemRefType.get((4, 8), f32))
def elemwise_exp_add_on_buffers(lhs, rhs, out): def elemwise_exp_add_on_buffers(lhs, rhs, out):
linalg.elemwise_unary(lhs, outs=[out], emit_generic=True) linalg.elemwise_unary(lhs, outs=[out], emit_generic=True)
linalg.elemwise_binary(out, rhs, outs=[out], emit_generic=True) linalg.elemwise_binary(out, rhs, outs=[out], emit_generic=True)
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
MemRefType.get((), f32), MemRefType.get((4, 8), f32), MemRefType.get((), f32), MemRefType.get((4, 8), f32),
MemRefType.get((4, 8), f32)) MemRefType.get((4, 8), f32))
def elemwise_log_mul_on_buffers(lhs, rhs, out): def elemwise_log_mul_on_buffers(lhs, rhs, out):
linalg.elemwise_unary( linalg.elemwise_unary(
lhs, outs=[out], fun=UnaryFn.log, emit_generic=True) lhs, outs=[out], fun=UnaryFn.log, emit_generic=True)
linalg.elemwise_binary( linalg.elemwise_binary(
out, rhs, outs=[out], fun=BinaryFn.mul, emit_generic=True) out, rhs, outs=[out], fun=BinaryFn.mul, emit_generic=True)
Show All 17 Lines
def test_matmul_builtin(): def test_matmul_builtin():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
i8 = IntegerType.get_signless(8) i8 = IntegerType.get_signless(8)
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
MemRefType.get((4, 16), i8), MemRefType.get((16, 8), f32), MemRefType.get((4, 16), i8), MemRefType.get((16, 8), f32),
MemRefType.get((4, 8), f32)) MemRefType.get((4, 8), f32))
def matmul_signed_on_buffers(lhs, rhs, out): def matmul_signed_on_buffers(lhs, rhs, out):
linalg.matmul(lhs, rhs, outs=[out]) linalg.matmul(lhs, rhs, outs=[out])
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
MemRefType.get((4, 16), i8), MemRefType.get((16, 8), f32), MemRefType.get((4, 16), i8), MemRefType.get((16, 8), f32),
MemRefType.get((4, 8), f32)) MemRefType.get((4, 8), f32))
def matmul_unsigned_on_buffers(lhs, rhs, out): def matmul_unsigned_on_buffers(lhs, rhs, out):
linalg.matmul(lhs, rhs, outs=[out], cast=TypeFn.cast_unsigned) linalg.matmul(lhs, rhs, outs=[out], cast=TypeFn.cast_unsigned)
execution_engine = ExecutionEngine(transform(module, matmul_boiler)) execution_engine = ExecutionEngine(transform(module, matmul_boiler))
# TODO: FFI-based solution to allow testing and printing with python code. # TODO: FFI-based solution to allow testing and printing with python code.
Show All 14 Lines
def test_matmul_generic(): def test_matmul_generic():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
i8 = IntegerType.get_signless(8) i8 = IntegerType.get_signless(8)
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
MemRefType.get((4, 16), i8), MemRefType.get((16, 8), f32), MemRefType.get((4, 16), i8), MemRefType.get((16, 8), f32),
MemRefType.get((4, 8), f32)) MemRefType.get((4, 8), f32))
def matmul_signed_on_buffers(lhs, rhs, out): def matmul_signed_on_buffers(lhs, rhs, out):
linalg.matmul(lhs, rhs, outs=[out], emit_generic=True) linalg.matmul(lhs, rhs, outs=[out], emit_generic=True)
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
MemRefType.get((4, 16), i8), MemRefType.get((16, 8), f32), MemRefType.get((4, 16), i8), MemRefType.get((16, 8), f32),
MemRefType.get((4, 8), f32)) MemRefType.get((4, 8), f32))
def matmul_unsigned_on_buffers(lhs, rhs, out): def matmul_unsigned_on_buffers(lhs, rhs, out):
linalg.matmul( linalg.matmul(
lhs, rhs, outs=[out], cast=TypeFn.cast_unsigned, emit_generic=True) lhs, rhs, outs=[out], cast=TypeFn.cast_unsigned, emit_generic=True)
execution_engine = ExecutionEngine(transform(module, matmul_boiler)) execution_engine = ExecutionEngine(transform(module, matmul_boiler))
Show All 15 Lines
def test_fill_builtin(): def test_fill_builtin():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
i32 = IntegerType.get_signless(32) i32 = IntegerType.get_signless(32)
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func(f32, MemRefType.get([], i32)) @func.FuncOp.from_py_func(f32, MemRefType.get([], i32))
def fill_0d_on_buffers(value, out): def fill_0d_on_buffers(value, out):
linalg.fill(value, outs=[out]) linalg.fill(value, outs=[out])
@builtin.FuncOp.from_py_func(f32, MemRefType.get([16], i32)) @func.FuncOp.from_py_func(f32, MemRefType.get([16], i32))
def fill_1d_on_buffers(value, out): def fill_1d_on_buffers(value, out):
linalg.fill(value, outs=[out]) linalg.fill(value, outs=[out])
@builtin.FuncOp.from_py_func(f32, MemRefType.get([4, 16], i32)) @func.FuncOp.from_py_func(f32, MemRefType.get([4, 16], i32))
def fill_2d_on_buffers(value, out): def fill_2d_on_buffers(value, out):
linalg.fill(value, outs=[out]) linalg.fill(value, outs=[out])
execution_engine = ExecutionEngine(transform(module, fill_boiler)) execution_engine = ExecutionEngine(transform(module, fill_boiler))
# TODO: FFI-based solution to allow testing and printing with python code. # TODO: FFI-based solution to allow testing and printing with python code.
# Prepare arguments: one result i32. # Prepare arguments: one result i32.
# Arguments must be passed as pointers. # Arguments must be passed as pointers.
Show All 10 Lines
def test_fill_generic(): def test_fill_generic():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
i32 = IntegerType.get_signless(32) i32 = IntegerType.get_signless(32)
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func(f32, MemRefType.get([], i32)) @func.FuncOp.from_py_func(f32, MemRefType.get([], i32))
def fill_0d_on_buffers(value, out): def fill_0d_on_buffers(value, out):
linalg.fill(value, outs=[out], emit_generic=True) linalg.fill(value, outs=[out], emit_generic=True)
@builtin.FuncOp.from_py_func(f32, MemRefType.get([16], i32)) @func.FuncOp.from_py_func(f32, MemRefType.get([16], i32))
def fill_1d_on_buffers(value, out): def fill_1d_on_buffers(value, out):
linalg.fill(value, outs=[out], emit_generic=True) linalg.fill(value, outs=[out], emit_generic=True)
@builtin.FuncOp.from_py_func(f32, MemRefType.get([4, 16], i32)) @func.FuncOp.from_py_func(f32, MemRefType.get([4, 16], i32))
def fill_2d_on_buffers(value, out): def fill_2d_on_buffers(value, out):
linalg.fill(value, outs=[out], emit_generic=True) linalg.fill(value, outs=[out], emit_generic=True)
execution_engine = ExecutionEngine(transform(module, fill_boiler)) execution_engine = ExecutionEngine(transform(module, fill_boiler))
# TODO: FFI-based solution to allow testing and printing with python code. # TODO: FFI-based solution to allow testing and printing with python code.
# Prepare arguments: one result i32. # Prepare arguments: one result i32.
# Arguments must be passed as pointers. # Arguments must be passed as pointers.
Show All 10 Lines
def test_fill_rng_builtin(): def test_fill_rng_builtin():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f64 = F64Type.get() f64 = F64Type.get()
i32 = IntegerType.get_signless(32) i32 = IntegerType.get_signless(32)
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func(f64, f64, i32, MemRefType.get((4, 16), i32)) @func.FuncOp.from_py_func(f64, f64, i32, MemRefType.get((4, 16), i32))
def fill_rng_on_buffers(min, max, seed, out): def fill_rng_on_buffers(min, max, seed, out):
linalg.fill_rng_2d(min, max, seed, outs=[out]) linalg.fill_rng_2d(min, max, seed, outs=[out])
execution_engine = ExecutionEngine(transform(module, fill_rng_boiler)) execution_engine = ExecutionEngine(transform(module, fill_rng_boiler))
# TODO: FFI-based solution to allow testing and printing with python code. # TODO: FFI-based solution to allow testing and printing with python code.
# Prepare arguments: one result i32. # Prepare arguments: one result i32.
# Arguments must be passed as pointers. # Arguments must be passed as pointers.
Show All 10 Lines
def test_fill_rng_generic(): def test_fill_rng_generic():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f64 = F64Type.get() f64 = F64Type.get()
i32 = IntegerType.get_signless(32) i32 = IntegerType.get_signless(32)
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func(f64, f64, i32, MemRefType.get((4, 16), i32)) @func.FuncOp.from_py_func(f64, f64, i32, MemRefType.get((4, 16), i32))
def fill_rng_on_buffers(min, max, seed, out): def fill_rng_on_buffers(min, max, seed, out):
linalg.fill_rng_2d(min, max, seed, outs=[out], emit_generic=True) linalg.fill_rng_2d(min, max, seed, outs=[out], emit_generic=True)
execution_engine = ExecutionEngine(transform(module, fill_rng_boiler)) execution_engine = ExecutionEngine(transform(module, fill_rng_boiler))
# TODO: FFI-based solution to allow testing and printing with python code. # TODO: FFI-based solution to allow testing and printing with python code.
# Prepare arguments: one result i32. # Prepare arguments: one result i32.
# Arguments must be passed as pointers. # Arguments must be passed as pointers.
Show All 10 Lines
def test_max_pooling_builtin(): def test_max_pooling_builtin():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f64 = F64Type.get() f64 = F64Type.get()
i32 = IntegerType.get_signless(32) i32 = IntegerType.get_signless(32)
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
MemRefType.get((1, 4, 16, 1), f64), MemRefType.get((2, 2), f64), MemRefType.get((1, 4, 16, 1), f64), MemRefType.get((2, 2), f64),
MemRefType.get((1, 2, 4, 1), i32)) MemRefType.get((1, 2, 4, 1), i32))
def pooling_on_buffers(input, shape, output): def pooling_on_buffers(input, shape, output):
linalg.pooling_nhwc_max( linalg.pooling_nhwc_max(
input, shape, outs=[output], strides=[2, 4], dilations=[1, 2]) input, shape, outs=[output], strides=[2, 4], dilations=[1, 2])
execution_engine = ExecutionEngine(transform(module, pooling_boiler)) execution_engine = ExecutionEngine(transform(module, pooling_boiler))
Show All 14 Lines
def test_max_pooling_generic(): def test_max_pooling_generic():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f64 = F64Type.get() f64 = F64Type.get()
i32 = IntegerType.get_signless(32) i32 = IntegerType.get_signless(32)
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
MemRefType.get((1, 4, 16, 1), f64), MemRefType.get((2, 2), f64), MemRefType.get((1, 4, 16, 1), f64), MemRefType.get((2, 2), f64),
MemRefType.get((1, 2, 4, 1), i32)) MemRefType.get((1, 2, 4, 1), i32))
def pooling_on_buffers(input, shape, output): def pooling_on_buffers(input, shape, output):
linalg.pooling_nhwc_max( linalg.pooling_nhwc_max(
input, input,
shape, shape,
outs=[output], outs=[output],
strides=[2, 4], strides=[2, 4],
Show All 19 Lines
def test_min_pooling_builtin(): def test_min_pooling_builtin():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f64 = F64Type.get() f64 = F64Type.get()
i32 = IntegerType.get_signless(32) i32 = IntegerType.get_signless(32)
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
MemRefType.get((1, 4, 16, 1), f64), MemRefType.get((2, 2), f64), MemRefType.get((1, 4, 16, 1), f64), MemRefType.get((2, 2), f64),
MemRefType.get((1, 2, 4, 1), i32)) MemRefType.get((1, 2, 4, 1), i32))
# Set the strides and use the default dilations. # Set the strides and use the default dilations.
def pooling_on_buffers(input, shape, output): def pooling_on_buffers(input, shape, output):
linalg.pooling_nhwc_min(input, shape, outs=[output], strides=[2, 4]) linalg.pooling_nhwc_min(input, shape, outs=[output], strides=[2, 4])
execution_engine = ExecutionEngine(transform(module, pooling_boiler)) execution_engine = ExecutionEngine(transform(module, pooling_boiler))
Show All 13 Lines
def test_min_pooling_generic(): def test_min_pooling_generic():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f64 = F64Type.get() f64 = F64Type.get()
i32 = IntegerType.get_signless(32) i32 = IntegerType.get_signless(32)
with InsertionPoint(module.body): with InsertionPoint(module.body):
@builtin.FuncOp.from_py_func( @func.FuncOp.from_py_func(
MemRefType.get((1, 4, 16, 1), f64), MemRefType.get((2, 2), f64), MemRefType.get((1, 4, 16, 1), f64), MemRefType.get((2, 2), f64),
MemRefType.get((1, 2, 4, 1), i32)) MemRefType.get((1, 2, 4, 1), i32))
# Set the strides and use the default dilations. # Set the strides and use the default dilations.
def pooling_on_buffers(input, shape, output): def pooling_on_buffers(input, shape, output):
linalg.pooling_nhwc_min( linalg.pooling_nhwc_min(
input, shape, outs=[output], strides=[2, 4], emit_generic=True) input, shape, outs=[output], strides=[2, 4], emit_generic=True)
execution_engine = ExecutionEngine(transform(module, pooling_boiler)) execution_engine = ExecutionEngine(transform(module, pooling_boiler))
Show All 13 Lines

mlir/test/python/ir/blocks.py

Show All 26 Lines
@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(
[IntegerType.get_signless(32), [IntegerType.get_signless(32),
IntegerType.get_signless(16)], []) IntegerType.get_signless(16)], [])
f_op = builtin.FuncOp("test", f_type) f_op = func.FuncOp("test", f_type)
entry_block = f_op.add_entry_block() entry_block = f_op.add_entry_block()
i32_arg, i16_arg = entry_block.arguments i32_arg, i16_arg = entry_block.arguments
successor_block = entry_block.create_after(i32_arg.type) successor_block = entry_block.create_after(i32_arg.type)
with InsertionPoint(successor_block) as successor_ip: with InsertionPoint(successor_block) as successor_ip:
assert successor_ip.block == successor_block assert successor_ip.block == successor_block
func.ReturnOp([]) func.ReturnOp([])
middle_block = successor_block.create_before(i16_arg.type) middle_block = successor_block.create_before(i16_arg.type)
Show All 13 Lines
# CHECK: func @test(%{{.*}}: f32) # CHECK: func @test(%{{.*}}: f32)
# CHECK: return # CHECK: return
@run @run
def testFirstBlockCreation(): def testFirstBlockCreation():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
with InsertionPoint(module.body): with InsertionPoint(module.body):
f = builtin.FuncOp("test", ([f32], [])) f = func.FuncOp("test", ([f32], []))
entry_block = Block.create_at_start(f.operation.regions[0], [f32]) entry_block = Block.create_at_start(f.operation.regions[0], [f32])
with InsertionPoint(entry_block): with InsertionPoint(entry_block):
func.ReturnOp([]) func.ReturnOp([])
print(module) print(module)
assert module.operation.verify() assert module.operation.verify()
assert f.body.blocks[0] == entry_block assert f.body.blocks[0] == entry_block

mlir/test/python/ir/operation.py

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Linesdef testTraverseOpRegionBlockIndices():
# CHECK: REGION 0: # CHECK: REGION 0:
# CHECK: BLOCK 0: # CHECK: BLOCK 0:
# CHECK: OP 0: func # CHECK: OP 0: func
# CHECK: OP 0: parent builtin.module # CHECK: OP 0: parent builtin.module
# CHECK: REGION 0: # CHECK: REGION 0:
# CHECK: BLOCK 0: # CHECK: BLOCK 0:
# CHECK: OP 0: %0 = "custom.addi" # CHECK: OP 0: %0 = "custom.addi"
# CHECK: OP 0: parent builtin.func # CHECK: OP 0: parent func.func
# CHECK: OP 1: return # CHECK: OP 1: return
# CHECK: OP 1: parent builtin.func # CHECK: OP 1: parent func.func
walk_operations("", module.operation) walk_operations("", module.operation)
# CHECK-LABEL: TEST: testBlockAndRegionOwners # CHECK-LABEL: TEST: testBlockAndRegionOwners
@run @run
def testBlockAndRegionOwners(): def testBlockAndRegionOwners():
ctx = Context() ctx = Context()
ctx.allow_unregistered_dialects = True ctx.allow_unregistered_dialects = True
module = Module.parse( module = Module.parse(
r""" r"""
builtin.module { builtin.module {
builtin.func @f() { func.func @f() {
func.return func.return
} }
} }
""", ctx) """, ctx)
assert module.operation.regions[0].owner == module.operation assert module.operation.regions[0].owner == module.operation
assert module.operation.regions[0].blocks[0].owner == module.operation assert module.operation.regions[0].blocks[0].owner == module.operation
▲ Show 20 Lines • Show All 715 Lines • Show Last 20 Lines

mlir/test/python/pass_manager.py

Show All 30 Lines
# Verify successful round-trip. # Verify successful round-trip.
# CHECK-LABEL: TEST: testParseSuccess # CHECK-LABEL: TEST: testParseSuccess
def testParseSuccess(): def testParseSuccess():
with Context(): with Context():
# A first import is expected to fail because the pass isn't registered # A first import is expected to fail because the pass isn't registered
# until we import mlir.transforms # until we import mlir.transforms
try: try:
pm = PassManager.parse("builtin.module(builtin.func(print-op-stats))") pm = PassManager.parse("builtin.module(func.func(print-op-stats))")
# TODO: this error should be propagate to Python but the C API does not help right now. # TODO: this error should be propagate to Python but the C API does not help right now.
# CHECK: error: 'print-op-stats' does not refer to a registered pass or pass pipeline # CHECK: error: 'print-op-stats' does not refer to a registered pass or pass pipeline
except ValueError as e: except ValueError as e:
# CHECK: ValueError exception: invalid pass pipeline 'builtin.module(builtin.func(print-op-stats))'. # CHECK: ValueError exception: invalid pass pipeline 'builtin.module(func.func(print-op-stats))'.
log("ValueError exception:", e) log("ValueError exception:", e)
else: else:
log("Exception not produced") log("Exception not produced")
# This will register the pass and round-trip should be possible now. # This will register the pass and round-trip should be possible now.
import mlir.transforms import mlir.transforms
pm = PassManager.parse("builtin.module(builtin.func(print-op-stats))") pm = PassManager.parse("builtin.module(func.func(print-op-stats))")
# CHECK: Roundtrip: builtin.module(builtin.func(print-op-stats)) # CHECK: Roundtrip: builtin.module(func.func(print-op-stats))
log("Roundtrip: ", pm) log("Roundtrip: ", pm)
run(testParseSuccess) run(testParseSuccess)
# Verify failure on unregistered pass. # Verify failure on unregistered pass.
# CHECK-LABEL: TEST: testParseFail # CHECK-LABEL: TEST: testParseFail
def testParseFail(): def testParseFail():
with Context(): with Context():
try: try:
pm = PassManager.parse("unknown-pass") pm = PassManager.parse("unknown-pass")
except ValueError as e: except ValueError as e:
# CHECK: ValueError exception: invalid pass pipeline 'unknown-pass'. # CHECK: ValueError exception: invalid pass pipeline 'unknown-pass'.
log("ValueError exception:", e) log("ValueError exception:", e)
else: else:
log("Exception not produced") log("Exception not produced")
run(testParseFail) run(testParseFail)
# Verify failure on incorrect level of nesting. # Verify failure on incorrect level of nesting.
# CHECK-LABEL: TEST: testInvalidNesting # CHECK-LABEL: TEST: testInvalidNesting
def testInvalidNesting(): def testInvalidNesting():
with Context(): with Context():
try: try:
import mlir.all_passes_registration import mlir.all_passes_registration
pm = PassManager.parse("builtin.func(normalize-memrefs)") pm = PassManager.parse("func.func(normalize-memrefs)")
except ValueError as e: except ValueError as e:
# CHECK: Can't add pass 'NormalizeMemRefs' restricted to 'builtin.module' on a PassManager intended to run on 'builtin.func', did you intend to nest? # CHECK: Can't add pass 'NormalizeMemRefs' restricted to 'builtin.module' on a PassManager intended to run on 'func.func', did you intend to nest?
# CHECK: ValueError exception: invalid pass pipeline 'builtin.func(normalize-memrefs)'. # CHECK: ValueError exception: invalid pass pipeline 'func.func(normalize-memrefs)'.
log("ValueError exception:", e) log("ValueError exception:", e)
else: else:
log("Exception not produced") log("Exception not produced")
run(testInvalidNesting) run(testInvalidNesting)
# Verify that a pass manager can execute on IR # Verify that a pass manager can execute on IR
# CHECK-LABEL: TEST: testRun # CHECK-LABEL: TEST: testRun
def testRunPipeline(): def testRunPipeline():
with Context(): with Context():
pm = PassManager.parse("print-op-stats") pm = PassManager.parse("print-op-stats")
module = Module.parse(r"""func @successfulParse() { return }""") module = Module.parse(r"""func @successfulParse() { return }""")
pm.run(module) pm.run(module)
# CHECK: Operations encountered: # CHECK: Operations encountered:
# CHECK: builtin.func , 1
# CHECK: builtin.module , 1 # CHECK: builtin.module , 1
# CHECK: func.func , 1
# CHECK: func.return , 1 # CHECK: func.return , 1
run(testRunPipeline) run(testRunPipeline)

mlir/unittests/ExecutionEngine/Invoke.cpp

//===- Invoke.cpp ------------------------------------*- C++ -*-===// //===- Invoke.cpp ------------------------------------*- C++ -*-===//
// //
// This file is licensed under the Apache License v2.0 with LLVM Exceptions. // This file is licensed 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/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h" #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h" #include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h" #include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.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/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/ExecutionEngine/CRunnerUtils.h" #include "mlir/ExecutionEngine/CRunnerUtils.h"
#include "mlir/ExecutionEngine/ExecutionEngine.h" #include "mlir/ExecutionEngine/ExecutionEngine.h"
#include "mlir/ExecutionEngine/MemRefUtils.h" #include "mlir/ExecutionEngine/MemRefUtils.h"
#include "mlir/ExecutionEngine/RunnerUtils.h" #include "mlir/ExecutionEngine/RunnerUtils.h"
#include "mlir/IR/MLIRContext.h" #include "mlir/IR/MLIRContext.h"
#include "mlir/InitAllDialects.h" #include "mlir/InitAllDialects.h"
#include "mlir/Parser/Parser.h" #include "mlir/Parser/Parser.h"
▲ Show 20 Lines • Show All 254 Lines • Show Last 20 Lines

mlir/unittests/IR/InterfaceAttachmentTest.cpp

Show First 20 Lines • Show All 272 Lines • ▼ Show 20 Lines
struct TestExternalOpOverridingModel struct TestExternalOpOverridingModel
: public TestExternalOpInterface::FallbackModel< : public TestExternalOpInterface::FallbackModel<
TestExternalOpOverridingModel> { TestExternalOpOverridingModel> {
unsigned getNameLengthPlusArg(Operation *op, unsigned arg) const { unsigned getNameLengthPlusArg(Operation *op, unsigned arg) const {
return op->getName().getStringRef().size() + arg; return op->getName().getStringRef().size() + arg;
} }
static unsigned getNameLengthPlusArgTwice(unsigned arg) { static unsigned getNameLengthPlusArgTwice(unsigned arg) {
return FuncOp::getOperationName().size() + 2 * arg; return UnrealizedConversionCastOp::getOperationName().size() + 2 * arg;
} }
unsigned getNameLengthTimesArg(Operation *op, unsigned arg) const { unsigned getNameLengthTimesArg(Operation *op, unsigned arg) const {
return 42; return 42;
} }
static unsigned getNameLengthMinusArg(unsigned arg) { return 21; } static unsigned getNameLengthMinusArg(unsigned arg) { return 21; }
}; };
TEST(InterfaceAttachment, Operation) { TEST(InterfaceAttachment, Operation) {
MLIRContext context; MLIRContext context;
OpBuilder builder(&context);
// Initially, the operation doesn't have the interface. // Initially, the operation doesn't have the interface.
OwningOpRef<ModuleOp> moduleOp = ModuleOp::create(UnknownLoc::get(&context)); OwningOpRef<ModuleOp> moduleOp =
builder.create<ModuleOp>(UnknownLoc::get(&context));
ASSERT_FALSE(isa<TestExternalOpInterface>(moduleOp->getOperation())); ASSERT_FALSE(isa<TestExternalOpInterface>(moduleOp->getOperation()));
// We can attach an external interface and now the operaiton has it. // We can attach an external interface and now the operaiton has it.
ModuleOp::attachInterface<TestExternalOpModel>(context); ModuleOp::attachInterface<TestExternalOpModel>(context);
auto iface = dyn_cast<TestExternalOpInterface>(moduleOp->getOperation()); auto iface = dyn_cast<TestExternalOpInterface>(moduleOp->getOperation());
ASSERT_TRUE(iface != nullptr); ASSERT_TRUE(iface != nullptr);
EXPECT_EQ(iface.getNameLengthPlusArg(10), 24u); EXPECT_EQ(iface.getNameLengthPlusArg(10), 24u);
EXPECT_EQ(iface.getNameLengthTimesArg(3), 42u); EXPECT_EQ(iface.getNameLengthTimesArg(3), 42u);
EXPECT_EQ(iface.getNameLengthPlusArgTwice(18), 50u); EXPECT_EQ(iface.getNameLengthPlusArgTwice(18), 50u);
EXPECT_EQ(iface.getNameLengthMinusArg(5), 9u); EXPECT_EQ(iface.getNameLengthMinusArg(5), 9u);
// Default implementation can be overridden. // Default implementation can be overridden.
OwningOpRef<FuncOp> funcOp = OwningOpRef<UnrealizedConversionCastOp> castOp =
FuncOp::create(UnknownLoc::get(&context), "function", builder.create<UnrealizedConversionCastOp>(UnknownLoc::get(&context),
FunctionType::get(&context, {}, {})); TypeRange(), ValueRange());
ASSERT_FALSE(isa<TestExternalOpInterface>(funcOp->getOperation())); ASSERT_FALSE(isa<TestExternalOpInterface>(castOp->getOperation()));
FuncOp::attachInterface<TestExternalOpOverridingModel>(context); UnrealizedConversionCastOp::attachInterface<TestExternalOpOverridingModel>(
iface = dyn_cast<TestExternalOpInterface>(funcOp->getOperation()); context);
iface = dyn_cast<TestExternalOpInterface>(castOp->getOperation());
ASSERT_TRUE(iface != nullptr); ASSERT_TRUE(iface != nullptr);
EXPECT_EQ(iface.getNameLengthPlusArg(10), 22u); EXPECT_EQ(iface.getNameLengthPlusArg(10), 44u);
EXPECT_EQ(iface.getNameLengthTimesArg(0), 42u); EXPECT_EQ(iface.getNameLengthTimesArg(0), 42u);
EXPECT_EQ(iface.getNameLengthPlusArgTwice(8), 28u); EXPECT_EQ(iface.getNameLengthPlusArgTwice(8), 50u);
EXPECT_EQ(iface.getNameLengthMinusArg(1000), 21u); EXPECT_EQ(iface.getNameLengthMinusArg(1000), 21u);
// Another context doesn't have the interfaces registered. // Another context doesn't have the interfaces registered.
MLIRContext other; MLIRContext other;
OwningOpRef<ModuleOp> otherModuleOp = OwningOpRef<ModuleOp> otherModuleOp =
ModuleOp::create(UnknownLoc::get(&other)); ModuleOp::create(UnknownLoc::get(&other));
ASSERT_FALSE(isa<TestExternalOpInterface>(otherModuleOp->getOperation())); ASSERT_FALSE(isa<TestExternalOpInterface>(otherModuleOp->getOperation()));
} }
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

mlir/unittests/Pass/AnalysisManagerTest.cpp

//===- AnalysisManagerTest.cpp - AnalysisManager unit tests ---------------===// //===- AnalysisManagerTest.cpp - AnalysisManager unit tests ---------------===//
// //
// 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/Pass/AnalysisManager.h" #include "mlir/Pass/AnalysisManager.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Pass/PassManager.h" #include "mlir/Pass/PassManager.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
using namespace mlir; using namespace mlir;
using namespace mlir::detail; using namespace mlir::detail;
Show All 28 LinesTEST(AnalysisManagerTest, FineGrainModuleAnalysisPreservation) {
// Check that only MyAnalysis is preserved. // Check that only MyAnalysis is preserved.
EXPECT_TRUE(am.getCachedAnalysis<MyAnalysis>().hasValue()); EXPECT_TRUE(am.getCachedAnalysis<MyAnalysis>().hasValue());
EXPECT_FALSE(am.getCachedAnalysis<OtherAnalysis>().hasValue()); EXPECT_FALSE(am.getCachedAnalysis<OtherAnalysis>().hasValue());
} }
TEST(AnalysisManagerTest, FineGrainFunctionAnalysisPreservation) { TEST(AnalysisManagerTest, FineGrainFunctionAnalysisPreservation) {
MLIRContext context; MLIRContext context;
context.loadDialect<func::FuncDialect>();
Builder builder(&context); Builder builder(&context);
// Create a function and a module. // Create a function and a module.
OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context))); OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
FuncOp func1 = FuncOp func1 =
FuncOp::create(builder.getUnknownLoc(), "foo", FuncOp::create(builder.getUnknownLoc(), "foo",
builder.getFunctionType(llvm::None, llvm::None)); builder.getFunctionType(llvm::None, llvm::None));
func1.setPrivate(); func1.setPrivate();
Show All 14 LinesTEST(AnalysisManagerTest, FineGrainFunctionAnalysisPreservation) {
// Check that only MyAnalysis is preserved. // Check that only MyAnalysis is preserved.
EXPECT_TRUE(fam.getCachedAnalysis<MyAnalysis>().hasValue()); EXPECT_TRUE(fam.getCachedAnalysis<MyAnalysis>().hasValue());
EXPECT_FALSE(fam.getCachedAnalysis<OtherAnalysis>().hasValue()); EXPECT_FALSE(fam.getCachedAnalysis<OtherAnalysis>().hasValue());
} }
TEST(AnalysisManagerTest, FineGrainChildFunctionAnalysisPreservation) { TEST(AnalysisManagerTest, FineGrainChildFunctionAnalysisPreservation) {
MLIRContext context; MLIRContext context;
context.loadDialect<func::FuncDialect>();
Builder builder(&context); Builder builder(&context);
// Create a function and a module. // Create a function and a module.
OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context))); OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
FuncOp func1 = FuncOp func1 =
FuncOp::create(builder.getUnknownLoc(), "foo", FuncOp::create(builder.getUnknownLoc(), "foo",
builder.getFunctionType(llvm::None, llvm::None)); builder.getFunctionType(llvm::None, llvm::None));
func1.setPrivate(); func1.setPrivate();
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

mlir/unittests/Pass/CMakeLists.txt

add_mlir_unittest(MLIRPassTests add_mlir_unittest(MLIRPassTests
AnalysisManagerTest.cpp AnalysisManagerTest.cpp
PassManagerTest.cpp PassManagerTest.cpp
PassPipelineParserTest.cpp PassPipelineParserTest.cpp
) )
target_link_libraries(MLIRPassTests target_link_libraries(MLIRPassTests
PRIVATE PRIVATE
MLIRFunc
MLIRPass) MLIRPass)

mlir/unittests/Pass/PassManagerTest.cpp

//===- PassManagerTest.cpp - PassManager unit tests -----------------------===// //===- PassManagerTest.cpp - PassManager unit tests -----------------------===//
// //
// 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/Pass/PassManager.h" #include "mlir/Pass/PassManager.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <memory> #include <memory>
using namespace mlir; using namespace mlir;
Show All 24 Lines void runOnOperation() override {
op->setAttr("isFunc", builder.getBoolAttr(ga.isFunc)); op->setAttr("isFunc", builder.getBoolAttr(ga.isFunc));
op->setAttr("isSecret", builder.getBoolAttr(sa.isSecret)); op->setAttr("isSecret", builder.getBoolAttr(sa.isSecret));
} }
}; };
TEST(PassManagerTest, OpSpecificAnalysis) { TEST(PassManagerTest, OpSpecificAnalysis) {
MLIRContext context; MLIRContext context;
context.loadDialect<func::FuncDialect>();
Builder builder(&context); Builder builder(&context);
// Create a module with 2 functions. // Create a module with 2 functions.
OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context))); OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
for (StringRef name : {"secret", "not_secret"}) { for (StringRef name : {"secret", "not_secret"}) {
FuncOp func = FuncOp func =
FuncOp::create(builder.getUnknownLoc(), name, FuncOp::create(builder.getUnknownLoc(), name,
builder.getFunctionType(llvm::None, llvm::None)); builder.getFunctionType(llvm::None, llvm::None));
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines