This is an archive of the discontinued LLVM Phabricator instance.

Differential D120778

[mlir][NFC] Rename StandardToLLVM to FuncToLLVM
ClosedPublic

Authored by rriddle on Mar 1 2022, 2:53 PM.

Details

Reviewers
antiagainst
aartbik
ftynse
awarzynski
nicolasvasilache
herhut
jsetoain
Commits
rG5a7b9194095b: [mlir][NFC] Rename StandardToLLVM to FuncToLLVM
Summary

The current StandardToLLVM conversion patterns only really handle
the Func dialect. The pass itself adds patterns for Arithmetic/CFToLLVM, but
those should be/will be split out in a followup. This commit focuses solely
on being an NFC rename.

Aside from the directory change, the pattern and pass creation API have been renamed:

  • populateStdToLLVMFuncOpConversionPattern -> populateFuncToLLVMFuncOpConversionPattern
  • populateStdToLLVMConversionPatterns -> populateFuncToLLVMConversionPatterns
  • createLowerToLLVMPass -> createConvertFuncToLLVMPass

Diff Detail

Event Timeline

rriddle created this revision.Mar 1 2022, 2:53 PM
Herald added a reviewer: antiagainst. · View Herald TranscriptMar 1 2022, 2:54 PM
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: ftynse. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: awarzynski. · View Herald Transcript
Herald added projects: Restricted Project, Restricted Project. · View Herald Transcript
Herald added subscribers: awarzynski, sdasgup3, wenzhicui and 26 others. · View Herald Transcript
rriddle requested review of this revision.Mar 1 2022, 2:54 PM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptMar 1 2022, 2:54 PM
Herald added a reviewer: herhut. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: stephenneuendorffer, nicolasvasilache, jdoerfert. · View Herald Transcript
rriddle updated this revision to Diff 412271.Mar 1 2022, 3:10 PM
rriddle edited the summary of this revision. (Show Details)
Herald added a reviewer: jsetoain. · View Herald TranscriptMar 1 2022, 3:10 PM
Harbormaster completed remote builds in B152065: Diff 412271.Mar 1 2022, 3:36 PM
rriddle added a child revision: D120791: [mlir][Pass] Add support for an InterfacePass and pass filtering based on OperationName.Mar 1 2022, 9:58 PM
rriddle updated this revision to Diff 412582.Mar 2 2022, 5:55 PM
Harbormaster completed remote builds in B152277: Diff 412582.Mar 2 2022, 6:24 PM
rriddle added a comment.Mar 4 2022, 9:14 AM

@ftynse Could you take a look when you have the chance? Essentially just an NFC rename.

ftynse accepted this revision.Mar 7 2022, 1:58 AM
This revision is now accepted and ready to land.Mar 7 2022, 1:58 AM
This revision was landed with ongoing or failed builds.Mar 7 2022, 11:25 AM
Closed by commit rG5a7b9194095b: [mlir][NFC] Rename StandardToLLVM to FuncToLLVM (authored by rriddle). · Explain Why
This revision was automatically updated to reflect the committed changes.
rriddle added a commit: rG5a7b9194095b: [mlir][NFC] Rename StandardToLLVM to FuncToLLVM.

Revision Contents

PathSize
flang/
lib/
Optimizer/
CodeGen/
4 lines
tools/
fir-opt/
3 lines
tco/
3 lines
mlir/
docs/
Dialects/
Linalg/
2 lines
10 lines
Tutorials/
Toy/
2 lines
examples/
toy/
Ch6/
mlir/
6 lines
Ch7/
mlir/
6 lines
include/
mlir/
Conversion/
FuncToLLVM/
StandardToLLVM/
ConvertFuncToLLVM.h
ConvertStandardToLLVM.h
24 lines
FuncToLLVM/
28 lines
2 lines
99 lines
SPIRVToLLVM/
4 lines
StandardToLLVM/
lib/
Conversion/
AsyncToLLVM/
2 lines
2 lines
2 lines
FuncToLLVM/
StandardToLLVM/
9 lines
FuncToLLVM.cpp
StandardToLLVM.cpp
45 lines
GPUCommon/
2 lines
6 lines
GPUToNVVM/
2 lines
4 lines
GPUToROCDL/
2 lines
4 lines
OpenMPToLLVM/
2 lines
6 lines
SPIRVToLLVM/
8 lines
7 lines
StandardToLLVM/
VectorToROCDL/
2 lines
4 lines
Dialect/
Linalg/
Transforms/
2 lines
SparseTensor/
Pipelines/
2 lines
ExecutionEngine/
2 lines
test/
CAPI/
2 lines
Conversion/
ComplexToLLVM/
2 lines
ComplexToStandard/
2 lines
FuncToLLVM/
StandardToLLVM/
4 lines
2 lines
2 lines
4 lines
4 lines
func-to-llvm.mlir
standard-to-llvm.mlir
4 lines
2 lines
FuncToLLVM/
6 lines
StandardToLLVM/
Dialect/
ArmSVE/
2 lines
Integration/
Dialect/
Async/
CPU/
4 lines
6 lines
6 lines
6 lines
Linalg/
CPU/
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
Memref/
2 lines
Standard/
CPU/
2 lines
2 lines
Vector/
CPU/
AMX/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
X86Vector/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
8 lines
8 lines
4 lines
4 lines
2 lines
2 lines
4 lines
GPU/
CUDA/
2 lines
Target/
LLVMIR/
2 lines
lib/
Conversion/
2 lines
FuncToLLVM/
StandardToLLVM/
6 lines
6 lines
StandardToLLVM/
mlir-cpu-runner/
X86Vector/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
mlir-opt/
2 lines
python/
2 lines
integration/
dialects/
linalg/
2 lines
tools/
mlir-opt/
2 lines
mlir-spirv-cpu-runner/
2 lines
mlir-vulkan-runner/
4 lines
unittests/
ExecutionEngine/
4 lines

Diff 412582

flang/lib/Optimizer/CodeGen/CodeGen.cpp

Show All 15 Lines
#include "flang/ISO_Fortran_binding.h" #include "flang/ISO_Fortran_binding.h"
#include "flang/Optimizer/Dialect/FIRAttr.h" #include "flang/Optimizer/Dialect/FIRAttr.h"
#include "flang/Optimizer/Dialect/FIROps.h" #include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Support/InternalNames.h" #include "flang/Optimizer/Support/InternalNames.h"
#include "flang/Optimizer/Support/TypeCode.h" #include "flang/Optimizer/Support/TypeCode.h"
#include "flang/Semantics/runtime-type-info.h" #include "flang/Semantics/runtime-type-info.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Target/LLVMIR/ModuleTranslation.h" #include "mlir/Target/LLVMIR/ModuleTranslation.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#define DEBUG_TYPE "flang-codegen" #define DEBUG_TYPE "flang-codegen"
▲ Show 20 Lines • Show All 3,269 Lines • ▼ Show 20 Lines pattern.insert<
NegcOpConversion, NoReassocOpConversion, SelectCaseOpConversion, NegcOpConversion, NoReassocOpConversion, SelectCaseOpConversion,
SelectOpConversion, SelectRankOpConversion, SelectTypeOpConversion, SelectOpConversion, SelectRankOpConversion, SelectTypeOpConversion,
ShapeOpConversion, ShapeShiftOpConversion, ShiftOpConversion, ShapeOpConversion, ShapeShiftOpConversion, ShiftOpConversion,
SliceOpConversion, StoreOpConversion, StringLitOpConversion, SliceOpConversion, StoreOpConversion, StringLitOpConversion,
SubcOpConversion, UnboxCharOpConversion, UnboxProcOpConversion, SubcOpConversion, UnboxCharOpConversion, UnboxProcOpConversion,
UndefOpConversion, UnreachableOpConversion, XArrayCoorOpConversion, UndefOpConversion, UnreachableOpConversion, XArrayCoorOpConversion,
XEmboxOpConversion, XReboxOpConversion, ZeroOpConversion>( XEmboxOpConversion, XReboxOpConversion, ZeroOpConversion>(
typeConverter); typeConverter);
mlir::populateStdToLLVMConversionPatterns(typeConverter, pattern); mlir::populateFuncToLLVMConversionPatterns(typeConverter, pattern);
mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter, mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
pattern); pattern);
mlir::cf::populateControlFlowToLLVMConversionPatterns(typeConverter, mlir::cf::populateControlFlowToLLVMConversionPatterns(typeConverter,
pattern); pattern);
mlir::ConversionTarget target{*context}; mlir::ConversionTarget target{*context};
target.addLegalDialect<mlir::LLVM::LLVMDialect>(); target.addLegalDialect<mlir::LLVM::LLVMDialect>();
// required NOPs for applying a full conversion // required NOPs for applying a full conversion
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

flang/tools/fir-opt/CMakeLists.txt

add_flang_tool(fir-opt fir-opt.cpp) add_flang_tool(fir-opt fir-opt.cpp)
llvm_update_compile_flags(fir-opt) llvm_update_compile_flags(fir-opt)
get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS) get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
target_link_libraries(fir-opt PRIVATE target_link_libraries(fir-opt PRIVATE
FIRDialect FIRDialect
FIRSupport FIRSupport
FIRTransforms FIRTransforms
FIRCodeGen FIRCodeGen
${dialect_libs} ${dialect_libs}
# TODO: these should be transitive dependencies from a target providing # TODO: these should be transitive dependencies from a target providing
# "registerFIRPasses()" # "registerFIRPasses()"
MLIRIR MLIRIR
MLIRLLVMIR MLIRLLVMIR
MLIRPass MLIRPass
MLIRStandardToLLVM MLIRFuncToLLVM
MLIRTransforms MLIRTransforms
MLIRAffineToStandard MLIRAffineToStandard
MLIRAnalysis MLIRAnalysis
MLIRSCFToControlFlow MLIRSCFToControlFlow
MLIRParser MLIRParser
MLIRStandardToLLVM
MLIRSupport MLIRSupport
MLIRVectorToLLVM MLIRVectorToLLVM
MLIROptLib MLIROptLib
) )

flang/tools/tco/CMakeLists.txt

add_flang_tool(tco tco.cpp) add_flang_tool(tco tco.cpp)
llvm_update_compile_flags(tco) llvm_update_compile_flags(tco)
get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS) get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
target_link_libraries(tco PRIVATE target_link_libraries(tco PRIVATE
FIRCodeGen FIRCodeGen
FIRDialect FIRDialect
FIRSupport FIRSupport
FIRTransforms FIRTransforms
FIRBuilder FIRBuilder
${dialect_libs} ${dialect_libs}
MLIRIR MLIRIR
MLIRLLVMIR MLIRLLVMIR
MLIRLLVMToLLVMIRTranslation MLIRLLVMToLLVMIRTranslation
MLIRTargetLLVMIRExport MLIRTargetLLVMIRExport
MLIRPass MLIRPass
MLIRStandardToLLVM MLIRFuncToLLVM
MLIRTransforms MLIRTransforms
MLIRAffineToStandard MLIRAffineToStandard
MLIRAnalysis MLIRAnalysis
MLIRSCFToControlFlow MLIRSCFToControlFlow
MLIRParser MLIRParser
MLIRStandardToLLVM
MLIRSupport MLIRSupport
MLIRVectorToLLVM MLIRVectorToLLVM
) )

mlir/docs/Dialects/Linalg/_index.md

Show First 20 Lines • Show All 409 Lines • ▼ Show 20 Linesfunc @example(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
return return
} }
func @pointwise_add(memref<?x?xf32, #map0>, memref<?x?xf32, #map0>, memref<?x?xf32, #map0>) attributes {llvm.emit_c_interface} func @pointwise_add(memref<?x?xf32, #map0>, memref<?x?xf32, #map0>, memref<?x?xf32, #map0>) attributes {llvm.emit_c_interface}
``` ```
Which, after lowering to LLVM resembles: Which, after lowering to LLVM resembles:
```mlir ```mlir
// Run: mlir-opt example4.mlir -convert-linalg-to-std | mlir-opt -convert-std-to-llvm // Run: mlir-opt example4.mlir -convert-linalg-to-std | mlir-opt -convert-func-to-llvm
// Some generated code are omitted here. // Some generated code are omitted here.
func @example(%arg0: !llvm<"float*">, ...) { func @example(%arg0: !llvm<"float*">, ...) {
... ...
llvm.call @pointwise_add(...) : (!llvm<"float*">, ...) -> () llvm.call @pointwise_add(...) : (!llvm<"float*">, ...) -> ()
return return
} }
llvm.func @pointwise_add(%arg0: !llvm<"float*">, ...) attributes {llvm.emit_c_interface} { llvm.func @pointwise_add(%arg0: !llvm<"float*">, ...) attributes {llvm.emit_c_interface} {
▲ Show 20 Lines • Show All 272 Lines • Show Last 20 Lines

mlir/docs/PassManagement.md

Show First 20 Lines • Show All 664 Lines • ▼ Show 20 Lines* `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-std-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-std-to-llvm{use-bare-ptr-memref-call-conv=1}' $ mlir-opt foo.mlir -pass-pipeline='builtin.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-std-to-llvm -mlir-timing -mlir-timing-display=list $ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='builtin.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-std-to-llvm -mlir-timing $ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='builtin.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%) 'builtin.func' Pipeline
Show All 14 Lines
slightly changes. First, a new timing column is added, `User Time`, that slightly changes. First, a new timing column is added, `User Time`, that
displays the total time spent across all threads. Secondly, the `Wall Time` displays the total time spent across all threads. Secondly, the `Wall Time`
column displays the longest individual time spent amongst all of the threads. column displays the longest individual time spent amongst all of the threads.
This means that the `Wall Time` column will continue to give an indicator on the This means that the `Wall Time` column will continue to give an indicator on the
perceived time, or clock time, whereas the `User Time` will display the total perceived time, or clock time, whereas the `User Time` will display the total
cpu time. cpu time.
```shell ```shell
$ mlir-opt foo.mlir -pass-pipeline='builtin.func(cse,canonicalize)' -convert-std-to-llvm -mlir-timing $ mlir-opt foo.mlir -pass-pipeline='builtin.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%) 'builtin.func' Pipeline
▲ Show 20 Lines • Show All 175 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
[transitive lowering](../../../getting_started/Glossary.md/#transitive-lowering). [transitive lowering](../../../getting_started/Glossary.md/#transitive-lowering).
```c++ ```c++
mlir::RewritePatternSet patterns(&getContext()); mlir::RewritePatternSet patterns(&getContext());
mlir::populateAffineToStdConversionPatterns(patterns, &getContext()); mlir::populateAffineToStdConversionPatterns(patterns, &getContext());
mlir::cf::populateSCFToControlFlowConversionPatterns(patterns, &getContext()); mlir::cf::populateSCFToControlFlowConversionPatterns(patterns, &getContext());
mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter, mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
patterns); patterns);
mlir::populateStdToLLVMConversionPatterns(typeConverter, patterns); mlir::populateFuncToLLVMConversionPatterns(typeConverter, patterns);
mlir::cf::populateControlFlowToLLVMConversionPatterns(patterns, &getContext()); mlir::cf::populateControlFlowToLLVMConversionPatterns(patterns, &getContext());
// The only remaining operation, to lower from the `toy` dialect, is the // The only remaining operation, to lower from the `toy` dialect, is the
// PrintOp. // PrintOp.
patterns.add<PrintOpLowering>(&getContext()); patterns.add<PrintOpLowering>(&getContext());
``` ```
### Full Lowering ### Full Lowering
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

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

Show All 22 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "toy/Dialect.h" #include "toy/Dialect.h"
#include "toy/Passes.h" #include "toy/Passes.h"
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h" #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h" #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
▲ Show 20 Lines • Show All 158 Lines • ▼ Show 20 Linesvoid ToyToLLVMLoweringPass::runOnOperation() {
// set of legal ones. // set of legal ones.
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateAffineToStdConversionPatterns(patterns); populateAffineToStdConversionPatterns(patterns);
populateSCFToControlFlowConversionPatterns(patterns); populateSCFToControlFlowConversionPatterns(patterns);
mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter, mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
patterns); patterns);
populateMemRefToLLVMConversionPatterns(typeConverter, patterns); populateMemRefToLLVMConversionPatterns(typeConverter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns); cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
populateStdToLLVMConversionPatterns(typeConverter, patterns); populateFuncToLLVMConversionPatterns(typeConverter, patterns);
// The only remaining operation to lower from the `toy` dialect, is the // The only remaining operation to lower from the `toy` dialect, is the
// PrintOp. // PrintOp.
patterns.add<PrintOpLowering>(&getContext()); patterns.add<PrintOpLowering>(&getContext());
// We want to completely lower to LLVM, so we use a `FullConversion`. This // We want to completely lower to LLVM, so we use a `FullConversion`. This
// ensures that only legal operations will remain after the conversion. // ensures that only legal operations will remain after the conversion.
auto module = getOperation(); auto module = getOperation();
Show All 9 Lines

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

Show All 22 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "toy/Dialect.h" #include "toy/Dialect.h"
#include "toy/Passes.h" #include "toy/Passes.h"
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h" #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h" #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
▲ Show 20 Lines • Show All 158 Lines • ▼ Show 20 Linesvoid ToyToLLVMLoweringPass::runOnOperation() {
// set of legal ones. // set of legal ones.
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateAffineToStdConversionPatterns(patterns); populateAffineToStdConversionPatterns(patterns);
populateSCFToControlFlowConversionPatterns(patterns); populateSCFToControlFlowConversionPatterns(patterns);
mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter, mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
patterns); patterns);
populateMemRefToLLVMConversionPatterns(typeConverter, patterns); populateMemRefToLLVMConversionPatterns(typeConverter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns); cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
populateStdToLLVMConversionPatterns(typeConverter, patterns); populateFuncToLLVMConversionPatterns(typeConverter, patterns);
// The only remaining operation to lower from the `toy` dialect, is the // The only remaining operation to lower from the `toy` dialect, is the
// PrintOp. // PrintOp.
patterns.add<PrintOpLowering>(&getContext()); patterns.add<PrintOpLowering>(&getContext());
// We want to completely lower to LLVM, so we use a `FullConversion`. This // We want to completely lower to LLVM, so we use a `FullConversion`. This
// ensures that only legal operations will remain after the conversion. // ensures that only legal operations will remain after the conversion.
auto module = getOperation(); auto module = getOperation();
Show All 9 Lines

mlir/include/mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h

  • This file was moved from mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h.
//===- ConvertStandardToLLVM.h - Convert to the LLVM dialect ----*- C++ -*-===// //===- ConvertFuncToLLVM.h - Convert Func to LLVM ---------------*- 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Provides a dialect conversion targeting the LLVM IR dialect. By default, it // Provides a set of conversion patterns from the Func dialect to the LLVM IR
// converts Standard ops and types and provides hooks for dialect-specific // dialect.
// extensions to the conversion.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVM_H #ifndef MLIR_CONVERSION_FUNCTOLLVM_CONVERTFUNCTOLLVM_H
#define MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVM_H #define MLIR_CONVERSION_FUNCTOLLVM_CONVERTFUNCTOLLVM_H
namespace mlir { namespace mlir {
class MLIRContext;
class LLVMTypeConverter; class LLVMTypeConverter;
class RewritePatternSet; class RewritePatternSet;
/// Collect the default pattern to convert a FuncOp to the LLVM dialect. If /// Collect the default pattern to convert a FuncOp to the LLVM dialect. If
/// `emitCWrappers` is set, the pattern will also produce functions /// `emitCWrappers` is set, the pattern will also produce functions
/// that pass memref descriptors by pointer-to-structure in addition to the /// that pass memref descriptors by pointer-to-structure in addition to the
/// default unpacked form. /// default unpacked form.
void populateStdToLLVMFuncOpConversionPattern(LLVMTypeConverter &converter, void populateFuncToLLVMFuncOpConversionPattern(LLVMTypeConverter &converter,
RewritePatternSet &patterns); RewritePatternSet &patterns);
/// Collect the patterns to convert from the Standard dialect to LLVM. The /// Collect the patterns to convert from the Func dialect to LLVM. The
/// conversion patterns capture the LLVMTypeConverter and the LowerToLLVMOptions /// conversion patterns capture the LLVMTypeConverter and the LowerToLLVMOptions
/// by reference meaning the references have to remain alive during the entire /// by reference meaning the references have to remain alive during the entire
/// pattern lifetime. /// pattern lifetime.
void populateStdToLLVMConversionPatterns(LLVMTypeConverter &converter, void populateFuncToLLVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns); RewritePatternSet &patterns);
} // namespace mlir } // namespace mlir
#endif // MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVM_H #endif // MLIR_CONVERSION_FUNCTOLLVM_CONVERTFUNCTOLLVM_H

mlir/include/mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h

  • This file was added.
//===- ConvertFuncToLLVMPass.h - Pass entrypoint ----------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef MLIR_CONVERSION_FUNCTOLLVM_CONVERTFUNCTOLLVMPASS_H_
#define MLIR_CONVERSION_FUNCTOLLVM_CONVERTFUNCTOLLVMPASS_H_
#include <memory>
namespace mlir {
class LowerToLLVMOptions;
class ModuleOp;
template <typename T>
class OperationPass;
class Pass;
/// Creates a pass to convert the Func dialect into the LLVMIR dialect.
std::unique_ptr<OperationPass<ModuleOp>> createConvertFuncToLLVMPass();
std::unique_ptr<OperationPass<ModuleOp>>
createConvertFuncToLLVMPass(const LowerToLLVMOptions &options);
} // namespace mlir
#endif // MLIR_CONVERSION_FUNCTOLLVM_CONVERTFUNCTOLLVMPASS_H_

mlir/include/mlir/Conversion/Passes.h

Show All 14 Lines
#include "mlir/Conversion/ArmNeon2dToIntr/ArmNeon2dToIntr.h" #include "mlir/Conversion/ArmNeon2dToIntr/ArmNeon2dToIntr.h"
#include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h" #include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h"
#include "mlir/Conversion/BufferizationToMemRef/BufferizationToMemRef.h" #include "mlir/Conversion/BufferizationToMemRef/BufferizationToMemRef.h"
#include "mlir/Conversion/ComplexToLLVM/ComplexToLLVM.h" #include "mlir/Conversion/ComplexToLLVM/ComplexToLLVM.h"
#include "mlir/Conversion/ComplexToStandard/ComplexToStandard.h" #include "mlir/Conversion/ComplexToStandard/ComplexToStandard.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRV.h" #include "mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRV.h"
#include "mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRVPass.h" #include "mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRVPass.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRVPass.h" #include "mlir/Conversion/FuncToSPIRV/FuncToSPIRVPass.h"
#include "mlir/Conversion/GPUCommon/GPUCommonPass.h" #include "mlir/Conversion/GPUCommon/GPUCommonPass.h"
#include "mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h" #include "mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h"
#include "mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h" #include "mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h"
#include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h" #include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h"
#include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h" #include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
#include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h" #include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
#include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h" #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h"
Show All 9 Lines
#include "mlir/Conversion/PDLToPDLInterp/PDLToPDLInterp.h" #include "mlir/Conversion/PDLToPDLInterp/PDLToPDLInterp.h"
#include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h" #include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h" #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Conversion/SCFToGPU/SCFToGPUPass.h" #include "mlir/Conversion/SCFToGPU/SCFToGPUPass.h"
#include "mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h" #include "mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h"
#include "mlir/Conversion/SCFToSPIRV/SCFToSPIRVPass.h" #include "mlir/Conversion/SCFToSPIRV/SCFToSPIRVPass.h"
#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h" #include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
#include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h" #include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Conversion/TensorToSPIRV/TensorToSPIRVPass.h" #include "mlir/Conversion/TensorToSPIRV/TensorToSPIRVPass.h"
#include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h" #include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h"
#include "mlir/Conversion/TosaToSCF/TosaToSCF.h" #include "mlir/Conversion/TosaToSCF/TosaToSCF.h"
#include "mlir/Conversion/TosaToStandard/TosaToStandard.h" #include "mlir/Conversion/TosaToStandard/TosaToStandard.h"
#include "mlir/Conversion/VectorToGPU/VectorToGPU.h" #include "mlir/Conversion/VectorToGPU/VectorToGPU.h"
#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/Conversion/VectorToSCF/VectorToSCF.h" #include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
Show All 11 Lines

mlir/include/mlir/Conversion/Passes.td

Show First 20 Lines • Show All 213 Lines • ▼ Show 20 Lines let options = [
Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types", Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
"bool", /*default=*/"true", "bool", /*default=*/"true",
"Emulate non-32-bit scalar types with 32-bit ones if " "Emulate non-32-bit scalar types with 32-bit ones if "
"missing native support"> "missing native support">
]; ];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// FuncToLLVM
//===----------------------------------------------------------------------===//
def ConvertFuncToLLVM : Pass<"convert-func-to-llvm", "ModuleOp"> {
let summary = "Convert from the Func dialect to the LLVM dialect";
let description = [{
Convert Func dialect operations into the LLVM IR dialect operations.
#### Input invariant
- no `tensor` types;
- all `vector` are one-dimensional;
- all blocks are reachable by following the successors of the first basic
block;
If other operations are present and their results are required by the LLVM
IR dialect operations, the pass will fail. Any LLVM IR operations or types
already present in the IR will be kept as is.
#### Output IR
Functions converted to LLVM IR. Function arguments types are converted
one-to-one. Function results are converted one-to-one and, in case more than
1 value is returned, packed into an LLVM IR struct type. Function calls and
returns are updated accordingly. Block argument types are updated to use
LLVM IR types.
}];
let constructor = "mlir::createConvertFuncToLLVMPass()";
let dependentDialects = ["LLVM::LLVMDialect"];
let options = [
Option<"useBarePtrCallConv", "use-bare-ptr-memref-call-conv", "bool",
/*default=*/"false",
"Replace FuncOp's MemRef arguments with bare pointers to the MemRef "
"element types">,
Option<"emitCWrappers", "emit-c-wrappers", "bool", /*default=*/"false",
"Emit wrappers for C-compatible pointer-to-struct memref "
"descriptors">,
Option<"indexBitwidth", "index-bitwidth", "unsigned",
/*default=kDeriveIndexBitwidthFromDataLayout*/"0",
"Bitwidth of the index type, 0 to use size of machine word">,
Option<"dataLayout", "data-layout", "std::string",
/*default=*/"\"\"",
"String description (LLVM format) of the data layout that is "
"expected on the produced module">
];
}
//===----------------------------------------------------------------------===//
// FuncToSPIRV // FuncToSPIRV
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ConvertFuncToSPIRV : Pass<"convert-func-to-spirv", "ModuleOp"> { def ConvertFuncToSPIRV : Pass<"convert-func-to-spirv", "ModuleOp"> {
let summary = "Convert Func dialect to SPIR-V dialect"; let summary = "Convert Func dialect to SPIR-V dialect";
let constructor = "mlir::createConvertFuncToSPIRVPass()"; let constructor = "mlir::createConvertFuncToSPIRVPass()";
let dependentDialects = ["spirv::SPIRVDialect"]; let dependentDialects = ["spirv::SPIRVDialect"];
let options = [ let options = [
▲ Show 20 Lines • Show All 383 Lines • ▼ Show 20 Lines let description = [{
See https://mlir.llvm.org/docs/SPIRVToLLVMDialectConversion/ See https://mlir.llvm.org/docs/SPIRVToLLVMDialectConversion/
for more details. for more details.
}]; }];
let constructor = "mlir::createConvertSPIRVToLLVMPass()"; let constructor = "mlir::createConvertSPIRVToLLVMPass()";
let dependentDialects = ["LLVM::LLVMDialect"]; let dependentDialects = ["LLVM::LLVMDialect"];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// StandardToLLVM
//===----------------------------------------------------------------------===//
def ConvertStandardToLLVM : Pass<"convert-std-to-llvm", "ModuleOp"> {
let summary = "Convert scalar and vector operations from the Standard to the "
"LLVM dialect";
let description = [{
Convert standard operations into the LLVM IR dialect operations.
#### Input invariant
- operations including: arithmetic on integers and floats, constants,
direct calls, returns and branches;
- no `tensor` types;
- all `vector` are one-dimensional;
- all blocks are reachable by following the successors of the first basic
block;
If other operations are present and their results are required by the LLVM
IR dialect operations, the pass will fail. Any LLVM IR operations or types
already present in the IR will be kept as is.
#### Output IR
Functions converted to LLVM IR. Function arguments types are converted
one-to-one. Function results are converted one-to-one and, in case more than
1 value is returned, packed into an LLVM IR struct type. Function calls and
returns are updated accordingly. Block argument types are updated to use
LLVM IR types.
}];
let constructor = "mlir::createLowerToLLVMPass()";
let dependentDialects = ["LLVM::LLVMDialect"];
let options = [
Option<"useBarePtrCallConv", "use-bare-ptr-memref-call-conv", "bool",
/*default=*/"false",
"Replace FuncOp's MemRef arguments with bare pointers to the MemRef "
"element types">,
Option<"emitCWrappers", "emit-c-wrappers", "bool", /*default=*/"false",
"Emit wrappers for C-compatible pointer-to-struct memref "
"descriptors">,
Option<"indexBitwidth", "index-bitwidth", "unsigned",
/*default=kDeriveIndexBitwidthFromDataLayout*/"0",
"Bitwidth of the index type, 0 to use size of machine word">,
Option<"dataLayout", "data-layout", "std::string",
/*default=*/"\"\"",
"String description (LLVM format) of the data layout that is "
"expected on the produced module">
];
}
//===----------------------------------------------------------------------===//
// TensorToSPIRV // TensorToSPIRV
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ConvertTensorToSPIRV : Pass<"convert-tensor-to-spirv", "ModuleOp"> { def ConvertTensorToSPIRV : Pass<"convert-tensor-to-spirv", "ModuleOp"> {
let summary = "Convert Tensor dialect to SPIR-V dialect"; let summary = "Convert Tensor dialect to SPIR-V dialect";
let constructor = "mlir::createConvertTensorToSPIRVPass()"; let constructor = "mlir::createConvertTensorToSPIRVPass()";
let dependentDialects = ["spirv::SPIRVDialect"]; let dependentDialects = ["spirv::SPIRVDialect"];
let options = [ let options = [
▲ Show 20 Lines • Show All 188 Lines • Show Last 20 Lines

mlir/include/mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h

Show All 20 Lines
class OperationPass; class OperationPass;
/// Creates a pass to emulate `gpu.launch_func` call in LLVM dialect and lower /// Creates a pass to emulate `gpu.launch_func` call in LLVM dialect and lower
/// the host module code to LLVM. /// the host module code to LLVM.
/// ///
/// This transformation creates a sequence of global variables that are later /// This transformation creates a sequence of global variables that are later
/// linked to the variables in the kernel module, and a series of copies to/from /// linked to the variables in the kernel module, and a series of copies to/from
/// them to emulate the memory transfer from the host or to the device sides. It /// them to emulate the memory transfer from the host or to the device sides. It
/// also converts the remaining Standard dialect into LLVM dialect, emitting C /// also converts the remaining Arithmetic, Func, and MemRef dialects into LLVM
/// wrappers. /// dialect, emitting C wrappers.
std::unique_ptr<OperationPass<ModuleOp>> createLowerHostCodeToLLVMPass(); std::unique_ptr<OperationPass<ModuleOp>> createLowerHostCodeToLLVMPass();
/// Creates a pass to convert SPIR-V operations to the LLVMIR dialect. /// Creates a pass to convert SPIR-V operations to the LLVMIR dialect.
std::unique_ptr<OperationPass<ModuleOp>> createConvertSPIRVToLLVMPass(); std::unique_ptr<OperationPass<ModuleOp>> createConvertSPIRVToLLVMPass();
} // namespace mlir } // namespace mlir
#endif // MLIR_CONVERSION_SPIRVTOLLVM_SPIRVTOLLVMPASS_H #endif // MLIR_CONVERSION_SPIRVTOLLVM_SPIRVTOLLVMPASS_H

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h

  • This file was moved to mlir/include/mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h.

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h

  • This file was deleted.
//===- ConvertStandardToLLVMPass.h - Pass entrypoint ------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVMPASS_H_
#define MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVMPASS_H_
#include <memory>
namespace mlir {
class LowerToLLVMOptions;
class ModuleOp;
template <typename T>
class OperationPass;
class Pass;
/// Creates a pass to convert the Standard dialect into the LLVMIR dialect.
/// stdlib malloc/free is used by default for allocating memrefs allocated with
/// memref.alloc, while LLVM's alloca is used for those allocated with
/// memref.alloca.
std::unique_ptr<OperationPass<ModuleOp>> createLowerToLLVMPass();
std::unique_ptr<OperationPass<ModuleOp>>
createLowerToLLVMPass(const LowerToLLVMOptions &options);
} // namespace mlir
#endif // MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVMPASS_H_

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

//===- AsyncToLLVM.cpp - Convert Async to LLVM dialect --------------------===// //===- AsyncToLLVM.cpp - Convert Async to LLVM dialect --------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h" #include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h"
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h" #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Async/IR/Async.h" #include "mlir/Dialect/Async/IR/Async.h"
#include "mlir/Dialect/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"
#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/IR/ImplicitLocOpBuilder.h" #include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/IR/TypeUtilities.h" #include "mlir/IR/TypeUtilities.h"
▲ Show 20 Lines • Show All 1,107 Lines • Show Last 20 Lines

mlir/lib/Conversion/AsyncToLLVM/CMakeLists.txt

add_mlir_conversion_library(MLIRAsyncToLLVM add_mlir_conversion_library(MLIRAsyncToLLVM
AsyncToLLVM.cpp AsyncToLLVM.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/AsyncToLLVM ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/AsyncToLLVM
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmetic MLIRArithmetic
MLIRAsync MLIRAsync
MLIRFuncToLLVM
MLIRFuncTransforms MLIRFuncTransforms
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMIR MLIRLLVMIR
MLIRStandardToLLVM
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/CMakeLists.txt

add_subdirectory(AffineToStandard) add_subdirectory(AffineToStandard)
add_subdirectory(ArithmeticToLLVM) add_subdirectory(ArithmeticToLLVM)
add_subdirectory(ArithmeticToSPIRV) add_subdirectory(ArithmeticToSPIRV)
add_subdirectory(ArmNeon2dToIntr) add_subdirectory(ArmNeon2dToIntr)
add_subdirectory(AsyncToLLVM) add_subdirectory(AsyncToLLVM)
add_subdirectory(BufferizationToMemRef) add_subdirectory(BufferizationToMemRef)
add_subdirectory(ComplexToLLVM) add_subdirectory(ComplexToLLVM)
add_subdirectory(ComplexToStandard) add_subdirectory(ComplexToStandard)
add_subdirectory(ControlFlowToLLVM) add_subdirectory(ControlFlowToLLVM)
add_subdirectory(ControlFlowToSPIRV) add_subdirectory(ControlFlowToSPIRV)
add_subdirectory(FuncToLLVM)
add_subdirectory(FuncToSPIRV) add_subdirectory(FuncToSPIRV)
add_subdirectory(GPUCommon) add_subdirectory(GPUCommon)
add_subdirectory(GPUToNVVM) add_subdirectory(GPUToNVVM)
add_subdirectory(GPUToROCDL) add_subdirectory(GPUToROCDL)
add_subdirectory(GPUToSPIRV) add_subdirectory(GPUToSPIRV)
add_subdirectory(GPUToVulkan) add_subdirectory(GPUToVulkan)
add_subdirectory(LinalgToLLVM) add_subdirectory(LinalgToLLVM)
add_subdirectory(LinalgToSPIRV) add_subdirectory(LinalgToSPIRV)
Show All 10 Lines
add_subdirectory(PDLToPDLInterp) add_subdirectory(PDLToPDLInterp)
add_subdirectory(ReconcileUnrealizedCasts) add_subdirectory(ReconcileUnrealizedCasts)
add_subdirectory(SCFToControlFlow) add_subdirectory(SCFToControlFlow)
add_subdirectory(SCFToGPU) add_subdirectory(SCFToGPU)
add_subdirectory(SCFToOpenMP) add_subdirectory(SCFToOpenMP)
add_subdirectory(SCFToSPIRV) add_subdirectory(SCFToSPIRV)
add_subdirectory(ShapeToStandard) add_subdirectory(ShapeToStandard)
add_subdirectory(SPIRVToLLVM) add_subdirectory(SPIRVToLLVM)
add_subdirectory(StandardToLLVM)
add_subdirectory(TensorToSPIRV) add_subdirectory(TensorToSPIRV)
add_subdirectory(TosaToLinalg) add_subdirectory(TosaToLinalg)
add_subdirectory(TosaToSCF) add_subdirectory(TosaToSCF)
add_subdirectory(TosaToStandard) add_subdirectory(TosaToStandard)
add_subdirectory(VectorToROCDL) add_subdirectory(VectorToROCDL)
add_subdirectory(VectorToLLVM) add_subdirectory(VectorToLLVM)
add_subdirectory(VectorToGPU) add_subdirectory(VectorToGPU)
add_subdirectory(VectorToSCF) add_subdirectory(VectorToSCF)
add_subdirectory(VectorToSPIRV) add_subdirectory(VectorToSPIRV)

mlir/lib/Conversion/FuncToLLVM/CMakeLists.txt

  • This file was moved from mlir/lib/Conversion/StandardToLLVM/CMakeLists.txt.
add_mlir_conversion_library(MLIRStandardToLLVM add_mlir_conversion_library(MLIRFuncToLLVM
StandardToLLVM.cpp FuncToLLVM.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/StandardToLLVM ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/FuncToLLVM
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
intrinsics_gen intrinsics_gen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAnalysis MLIRAnalysis
MLIRArithmeticToLLVM MLIRArithmeticToLLVM
MLIRControlFlowToLLVM MLIRControlFlowToLLVM
MLIRDataLayoutInterfaces MLIRDataLayoutInterfaces
MLIRFunc MLIRFunc
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMIR MLIRLLVMIR
MLIRMath MLIRTransformUtils
MLIRTransforms
) )

mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp

  • This file was moved from mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp.
//===- StandardToLLVM.cpp - Standard to LLVM dialect conversion -----------===// //===- FuncToLLVM.cpp - Func to LLVM dialect conversion -------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to convert MLIR standard and builtin dialects // This file implements a pass to convert MLIR Func and builtin dialects
// into the LLVM IR dialect. // into the LLVM IR dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Analysis/DataLayoutAnalysis.h" #include "mlir/Analysis/DataLayoutAnalysis.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/LLVMCommon/VectorPattern.h" #include "mlir/Conversion/LLVMCommon/VectorPattern.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Dialect/Func/IR/FuncOps.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/Utils/StaticValueUtils.h" #include "mlir/Dialect/Utils/StaticValueUtils.h"
#include "mlir/IR/Attributes.h" #include "mlir/IR/Attributes.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/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/IR/TypeUtilities.h" #include "mlir/IR/TypeUtilities.h"
#include "mlir/Support/LogicalResult.h" #include "mlir/Support/LogicalResult.h"
#include "mlir/Support/MathExtras.h" #include "mlir/Support/MathExtras.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/Passes.h" #include "mlir/Transforms/Passes.h"
#include "llvm/ADT/TypeSwitch.h" #include "llvm/ADT/TypeSwitch.h"
#include "llvm/IR/DerivedTypes.h" #include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/IRBuilder.h" #include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Type.h" #include "llvm/IR/Type.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/FormatVariadic.h"
#include <functional> #include <functional>
using namespace mlir; using namespace mlir;
#define PASS_NAME "convert-std-to-llvm" #define PASS_NAME "convert-func-to-llvm"
/// Only retain those attributes that are not constructed by /// Only retain those attributes that are not constructed by
/// `LLVMFuncOp::build`. If `filterArgAttrs` is set, also filter out argument /// `LLVMFuncOp::build`. If `filterArgAttrs` is set, also filter out argument
/// attributes. /// attributes.
static void filterFuncAttributes(ArrayRef<NamedAttribute> attrs, static void filterFuncAttributes(ArrayRef<NamedAttribute> attrs,
bool filterArgAttrs, bool filterArgAttrs,
SmallVectorImpl<NamedAttribute> &result) { SmallVectorImpl<NamedAttribute> &result) {
for (const auto &attr : attrs) { for (const auto &attr : attrs) {
▲ Show 20 Lines • Show All 518 Lines • ▼ Show 20 Lines matchAndRewrite(func::ReturnOp op, OpAdaptor adaptor,
} }
rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, TypeRange(), packed, rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, TypeRange(), packed,
op->getAttrs()); op->getAttrs());
return success(); return success();
} }
}; };
} // namespace } // namespace
void mlir::populateStdToLLVMFuncOpConversionPattern( void mlir::populateFuncToLLVMFuncOpConversionPattern(
LLVMTypeConverter &converter, RewritePatternSet &patterns) { LLVMTypeConverter &converter, RewritePatternSet &patterns) {
if (converter.getOptions().useBarePtrCallConv) if (converter.getOptions().useBarePtrCallConv)
patterns.add<BarePtrFuncOpConversion>(converter); patterns.add<BarePtrFuncOpConversion>(converter);
else else
patterns.add<FuncOpConversion>(converter); patterns.add<FuncOpConversion>(converter);
} }
void mlir::populateStdToLLVMConversionPatterns(LLVMTypeConverter &converter, void mlir::populateFuncToLLVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns) { RewritePatternSet &patterns) {
populateStdToLLVMFuncOpConversionPattern(converter, patterns); populateFuncToLLVMFuncOpConversionPattern(converter, patterns);
// clang-format off // clang-format off
patterns.add< patterns.add<
CallIndirectOpLowering, CallIndirectOpLowering,
CallOpLowering, CallOpLowering,
ConstantOpLowering, ConstantOpLowering,
ReturnOpLowering>(converter); ReturnOpLowering>(converter);
// clang-format on // clang-format on
} }
namespace { namespace {
/// A pass converting MLIR operations into the LLVM IR dialect. /// A pass converting Func operations into the LLVM IR dialect.
struct LLVMLoweringPass : public ConvertStandardToLLVMBase<LLVMLoweringPass> { struct ConvertFuncToLLVMPass
LLVMLoweringPass() = default; : public ConvertFuncToLLVMBase<ConvertFuncToLLVMPass> {
LLVMLoweringPass(bool useBarePtrCallConv, bool emitCWrappers, ConvertFuncToLLVMPass() = default;
ConvertFuncToLLVMPass(bool useBarePtrCallConv, bool emitCWrappers,
unsigned indexBitwidth, bool useAlignedAlloc, unsigned indexBitwidth, bool useAlignedAlloc,
const llvm::DataLayout &dataLayout) { const llvm::DataLayout &dataLayout) {
this->useBarePtrCallConv = useBarePtrCallConv; this->useBarePtrCallConv = useBarePtrCallConv;
this->emitCWrappers = emitCWrappers; this->emitCWrappers = emitCWrappers;
this->indexBitwidth = indexBitwidth; this->indexBitwidth = indexBitwidth;
this->dataLayout = dataLayout.getStringRepresentation(); this->dataLayout = dataLayout.getStringRepresentation();
} }
/// Run the dialect converter on the module. /// Run the dialect converter on the module.
void runOnOperation() override { void runOnOperation() override {
Show All 22 Lines void runOnOperation() override {
if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout) if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout)
options.overrideIndexBitwidth(indexBitwidth); options.overrideIndexBitwidth(indexBitwidth);
options.dataLayout = llvm::DataLayout(this->dataLayout); options.dataLayout = llvm::DataLayout(this->dataLayout);
LLVMTypeConverter typeConverter(&getContext(), options, LLVMTypeConverter typeConverter(&getContext(), options,
&dataLayoutAnalysis); &dataLayoutAnalysis);
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateStdToLLVMConversionPatterns(typeConverter, patterns); populateFuncToLLVMConversionPatterns(typeConverter, patterns);
// TODO: Remove these in favor of their dedicated conversion passes.
arith::populateArithmeticToLLVMConversionPatterns(typeConverter, patterns); arith::populateArithmeticToLLVMConversionPatterns(typeConverter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns); cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
if (failed(applyPartialConversion(m, target, std::move(patterns)))) if (failed(applyPartialConversion(m, target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
m->setAttr(LLVM::LLVMDialect::getDataLayoutAttrName(), m->setAttr(LLVM::LLVMDialect::getDataLayoutAttrName(),
StringAttr::get(m.getContext(), this->dataLayout)); StringAttr::get(m.getContext(), this->dataLayout));
} }
}; };
} // namespace } // namespace
std::unique_ptr<OperationPass<ModuleOp>> mlir::createLowerToLLVMPass() { std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertFuncToLLVMPass() {
return std::make_unique<LLVMLoweringPass>(); return std::make_unique<ConvertFuncToLLVMPass>();
} }
std::unique_ptr<OperationPass<ModuleOp>> std::unique_ptr<OperationPass<ModuleOp>>
mlir::createLowerToLLVMPass(const LowerToLLVMOptions &options) { mlir::createConvertFuncToLLVMPass(const LowerToLLVMOptions &options) {
auto allocLowering = options.allocLowering; auto allocLowering = options.allocLowering;
// There is no way to provide additional patterns for pass, so // There is no way to provide additional patterns for pass, so
// AllocLowering::None will always fail. // AllocLowering::None will always fail.
assert(allocLowering != LowerToLLVMOptions::AllocLowering::None && assert(allocLowering != LowerToLLVMOptions::AllocLowering::None &&
"LLVMLoweringPass doesn't support AllocLowering::None"); "ConvertFuncToLLVMPass doesn't support AllocLowering::None");
bool useAlignedAlloc = bool useAlignedAlloc =
(allocLowering == LowerToLLVMOptions::AllocLowering::AlignedAlloc); (allocLowering == LowerToLLVMOptions::AllocLowering::AlignedAlloc);
return std::make_unique<LLVMLoweringPass>( return std::make_unique<ConvertFuncToLLVMPass>(
options.useBarePtrCallConv, options.emitCWrappers, options.useBarePtrCallConv, options.emitCWrappers,
options.getIndexBitwidth(), useAlignedAlloc, options.dataLayout); options.getIndexBitwidth(), useAlignedAlloc, options.dataLayout);
} }

mlir/lib/Conversion/GPUCommon/CMakeLists.txt

Show All 26 Linesadd_mlir_conversion_library(MLIRGPUToGPURuntimeTransforms
MC MC
${AMDGPU_LIBS} ${AMDGPU_LIBS}
${NVPTX_LIBS} ${NVPTX_LIBS}
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticToLLVM MLIRArithmeticToLLVM
MLIRAsyncToLLVM MLIRAsyncToLLVM
MLIRControlFlowToLLVM MLIRControlFlowToLLVM
MLIRFuncToLLVM
MLIRGPUTransforms MLIRGPUTransforms
MLIRIR MLIRIR
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMIR MLIRLLVMIR
MLIRMemRefToLLVM MLIRMemRefToLLVM
MLIRPass MLIRPass
MLIRSupport MLIRSupport
MLIRStandardToLLVM
MLIRVectorToLLVM MLIRVectorToLLVM
) )

mlir/lib/Conversion/GPUCommon/GPUToLLVMConversion.cpp

Show All 13 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/GPUCommon/GPUCommonPass.h" #include "mlir/Conversion/GPUCommon/GPUCommonPass.h"
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h" #include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h" #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
#include "mlir/Dialect/Async/IR/Async.h" #include "mlir/Dialect/Async/IR/Async.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/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/IR/Attributes.h" #include "mlir/IR/Attributes.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
▲ Show 20 Lines • Show All 334 Lines • ▼ Show 20 Linesvoid GpuToLLVMConversionPass::runOnOperation() {
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
target.addIllegalDialect<gpu::GPUDialect>(); target.addIllegalDialect<gpu::GPUDialect>();
mlir::arith::populateArithmeticToLLVMConversionPatterns(converter, patterns); mlir::arith::populateArithmeticToLLVMConversionPatterns(converter, patterns);
mlir::cf::populateControlFlowToLLVMConversionPatterns(converter, patterns); mlir::cf::populateControlFlowToLLVMConversionPatterns(converter, patterns);
populateVectorToLLVMConversionPatterns(converter, patterns); populateVectorToLLVMConversionPatterns(converter, patterns);
populateMemRefToLLVMConversionPatterns(converter, patterns); populateMemRefToLLVMConversionPatterns(converter, patterns);
populateStdToLLVMConversionPatterns(converter, patterns); populateFuncToLLVMConversionPatterns(converter, patterns);
populateAsyncStructuralTypeConversionsAndLegality(converter, patterns, populateAsyncStructuralTypeConversionsAndLegality(converter, patterns,
target); target);
populateGpuToLLVMConversionPatterns(converter, patterns, gpuBinaryAnnotation); populateGpuToLLVMConversionPatterns(converter, patterns, gpuBinaryAnnotation);
if (failed( if (failed(
applyPartialConversion(getOperation(), target, std::move(patterns)))) applyPartialConversion(getOperation(), target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
▲ Show 20 Lines • Show All 514 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUToNVVM/CMakeLists.txt

set(LLVM_TARGET_DEFINITIONS GPUToNVVM.td) set(LLVM_TARGET_DEFINITIONS GPUToNVVM.td)
mlir_tablegen(GPUToNVVM.cpp.inc -gen-rewriters) mlir_tablegen(GPUToNVVM.cpp.inc -gen-rewriters)
add_public_tablegen_target(MLIRGPUToNVVMIncGen) add_public_tablegen_target(MLIRGPUToNVVMIncGen)
add_mlir_conversion_library(MLIRGPUToNVVMTransforms add_mlir_conversion_library(MLIRGPUToNVVMTransforms
LowerGpuOpsToNVVMOps.cpp LowerGpuOpsToNVVMOps.cpp
WmmaOpsToNvvm.cpp WmmaOpsToNvvm.cpp
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
MLIRGPUToNVVMIncGen MLIRGPUToNVVMIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticToLLVM MLIRArithmeticToLLVM
MLIRFuncToLLVM
MLIRGPUOps MLIRGPUOps
MLIRGPUToGPURuntimeTransforms MLIRGPUToGPURuntimeTransforms
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMIR MLIRLLVMIR
MLIRMemRefToLLVM MLIRMemRefToLLVM
MLIRNVVMIR MLIRNVVMIR
MLIRPass MLIRPass
MLIRStandardToLLVM
MLIRTransformUtils MLIRTransformUtils
) )

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

Show All 9 Lines
// GPU operations. // GPU operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h" #include "mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.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/StandardToLLVM/ConvertStandardToLLVM.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/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"
▲ Show 20 Lines • Show All 228 Lines • ▼ Show 20 Lines void runOnOperation() override {
// Apply in-dialect lowering first. In-dialect lowering will replace ops // Apply in-dialect lowering first. In-dialect lowering will replace ops
// which need to be lowered further, which is not supported by a single // which need to be lowered further, which is not supported by a single
// conversion pass. // conversion pass.
populateGpuRewritePatterns(patterns); populateGpuRewritePatterns(patterns);
(void)applyPatternsAndFoldGreedily(m, std::move(patterns)); (void)applyPatternsAndFoldGreedily(m, std::move(patterns));
arith::populateArithmeticToLLVMConversionPatterns(converter, llvmPatterns); arith::populateArithmeticToLLVMConversionPatterns(converter, llvmPatterns);
cf::populateControlFlowToLLVMConversionPatterns(converter, llvmPatterns); cf::populateControlFlowToLLVMConversionPatterns(converter, llvmPatterns);
populateStdToLLVMConversionPatterns(converter, llvmPatterns); populateFuncToLLVMConversionPatterns(converter, llvmPatterns);
populateMemRefToLLVMConversionPatterns(converter, llvmPatterns); populateMemRefToLLVMConversionPatterns(converter, llvmPatterns);
populateGpuToNVVMConversionPatterns(converter, llvmPatterns); populateGpuToNVVMConversionPatterns(converter, llvmPatterns);
populateGpuWMMAToNVVMConversionPatterns(converter, llvmPatterns); populateGpuWMMAToNVVMConversionPatterns(converter, llvmPatterns);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
configureGpuToNVVMConversionLegality(target); configureGpuToNVVMConversionLegality(target);
if (failed(applyPartialConversion(m, target, std::move(llvmPatterns)))) if (failed(applyPartialConversion(m, target, std::move(llvmPatterns))))
signalPassFailure(); signalPassFailure();
} }
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUToROCDL/CMakeLists.txt

set(LLVM_TARGET_DEFINITIONS GPUToROCDL.td) set(LLVM_TARGET_DEFINITIONS GPUToROCDL.td)
mlir_tablegen(GPUToROCDL.cpp.inc -gen-rewriters) mlir_tablegen(GPUToROCDL.cpp.inc -gen-rewriters)
add_public_tablegen_target(MLIRGPUToROCDLIncGen) add_public_tablegen_target(MLIRGPUToROCDLIncGen)
add_mlir_conversion_library(MLIRGPUToROCDLTransforms add_mlir_conversion_library(MLIRGPUToROCDLTransforms
LowerGpuOpsToROCDLOps.cpp LowerGpuOpsToROCDLOps.cpp
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
MLIRGPUToROCDLIncGen MLIRGPUToROCDLIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticToLLVM MLIRArithmeticToLLVM
MLIRFuncToLLVM
MLIRGPUOps MLIRGPUOps
MLIRGPUToGPURuntimeTransforms MLIRGPUToGPURuntimeTransforms
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMIR MLIRLLVMIR
MLIRMemRefToLLVM MLIRMemRefToLLVM
MLIRROCDLIR MLIRROCDLIR
MLIRPass MLIRPass
MLIRStandardToLLVM
MLIRVectorToROCDL MLIRVectorToROCDL
) )

mlir/lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp

Show All 9 Lines
// GPU operations. // GPU operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h" #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h" #include "mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.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/StandardToLLVM/ConvertStandardToLLVM.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/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"
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines void runOnOperation() override {
populateGpuRewritePatterns(patterns); populateGpuRewritePatterns(patterns);
(void)applyPatternsAndFoldGreedily(m, std::move(patterns)); (void)applyPatternsAndFoldGreedily(m, std::move(patterns));
mlir::arith::populateArithmeticToLLVMConversionPatterns(converter, mlir::arith::populateArithmeticToLLVMConversionPatterns(converter,
llvmPatterns); llvmPatterns);
populateVectorToLLVMConversionPatterns(converter, llvmPatterns); populateVectorToLLVMConversionPatterns(converter, llvmPatterns);
populateVectorToROCDLConversionPatterns(converter, llvmPatterns); populateVectorToROCDLConversionPatterns(converter, llvmPatterns);
cf::populateControlFlowToLLVMConversionPatterns(converter, llvmPatterns); cf::populateControlFlowToLLVMConversionPatterns(converter, llvmPatterns);
populateStdToLLVMConversionPatterns(converter, llvmPatterns); populateFuncToLLVMConversionPatterns(converter, llvmPatterns);
populateMemRefToLLVMConversionPatterns(converter, llvmPatterns); populateMemRefToLLVMConversionPatterns(converter, llvmPatterns);
populateGpuToROCDLConversionPatterns(converter, llvmPatterns, runtime); populateGpuToROCDLConversionPatterns(converter, llvmPatterns, runtime);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
configureGpuToROCDLConversionLegality(target); configureGpuToROCDLConversionLegality(target);
if (failed(applyPartialConversion(m, target, std::move(llvmPatterns)))) if (failed(applyPartialConversion(m, target, std::move(llvmPatterns))))
signalPassFailure(); signalPassFailure();
} }
}; };
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

mlir/lib/Conversion/OpenMPToLLVM/CMakeLists.txt

add_mlir_conversion_library(MLIROpenMPToLLVM add_mlir_conversion_library(MLIROpenMPToLLVM
OpenMPToLLVM.cpp OpenMPToLLVM.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/OpenMPToLLVM ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/OpenMPToLLVM
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
intrinsics_gen intrinsics_gen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticToLLVM MLIRArithmeticToLLVM
MLIRFuncToLLVM
MLIRIR MLIRIR
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMIR MLIRLLVMIR
MLIRMemRefToLLVM MLIRMemRefToLLVM
MLIROpenMP MLIROpenMP
MLIRStandardToLLVM
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/OpenMPToLLVM/OpenMPToLLVM.cpp

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

mlir/lib/Conversion/SPIRVToLLVM/CMakeLists.txt

add_mlir_conversion_library(MLIRSPIRVToLLVM add_mlir_conversion_library(MLIRSPIRVToLLVM
ConvertLaunchFuncToLLVMCalls.cpp ConvertLaunchFuncToLLVMCalls.cpp
SPIRVToLLVM.cpp SPIRVToLLVM.cpp
SPIRVToLLVMPass.cpp SPIRVToLLVMPass.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SPIRVToLLVM ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SPIRVToLLVM
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
intrinsics_gen intrinsics_gen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRArithmeticToLLVM MLIRArithmeticToLLVM
MLIRFuncToLLVM
MLIRGPUOps MLIRGPUOps
MLIRSPIRV MLIRIR
MLIRSPIRVUtils
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMIR MLIRLLVMIR
MLIRMemRefToLLVM MLIRMemRefToLLVM
MLIRStandardToLLVM MLIRSPIRV
MLIRIR MLIRSPIRVUtils
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/SPIRVToLLVM/ConvertLaunchFuncToLLVMCalls.cpp

//===- ConvertLaunchFuncToLLVMCalls.cpp - MLIR GPU launch to LLVM pass ----===// //===- ConvertLaunchFuncToLLVMCalls.cpp - MLIR GPU launch to LLVM 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 passes to convert `gpu.launch_func` op into a sequence // This file implements passes to convert `gpu.launch_func` op into a sequence
// of LLVM calls that emulate the host and device sides. // of LLVM calls that emulate the host and device sides.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h" #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/LoweringOptions.h" #include "mlir/Conversion/LLVMCommon/LoweringOptions.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h" #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVM.h" #include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVM.h"
#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h" #include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/SymbolTable.h" #include "mlir/IR/SymbolTable.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
▲ Show 20 Lines • Show All 244 Lines • ▼ Show 20 Linespublic:
void runOnOperation() override { void runOnOperation() override {
ModuleOp module = getOperation(); ModuleOp module = getOperation();
// Erase the GPU module. // Erase the GPU module.
for (auto gpuModule : for (auto gpuModule :
llvm::make_early_inc_range(module.getOps<gpu::GPUModuleOp>())) llvm::make_early_inc_range(module.getOps<gpu::GPUModuleOp>()))
gpuModule.erase(); gpuModule.erase();
// Specify options to lower Standard to LLVM and pull in the conversion // Specify options to lower to LLVM and pull in the conversion patterns.
// patterns.
LowerToLLVMOptions options(module.getContext()); LowerToLLVMOptions options(module.getContext());
options.emitCWrappers = true; options.emitCWrappers = true;
auto *context = module.getContext(); auto *context = module.getContext();
RewritePatternSet patterns(context); RewritePatternSet patterns(context);
LLVMTypeConverter typeConverter(context, options); LLVMTypeConverter typeConverter(context, options);
mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter, mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
patterns); patterns);
populateMemRefToLLVMConversionPatterns(typeConverter, patterns); populateMemRefToLLVMConversionPatterns(typeConverter, patterns);
populateStdToLLVMConversionPatterns(typeConverter, patterns); populateFuncToLLVMConversionPatterns(typeConverter, patterns);
patterns.add<GPULaunchLowering>(typeConverter); patterns.add<GPULaunchLowering>(typeConverter);
// Pull in SPIR-V type conversion patterns to convert SPIR-V global // Pull in SPIR-V type conversion patterns to convert SPIR-V global
// variable's type to LLVM dialect type. // variable's type to LLVM dialect type.
populateSPIRVToLLVMTypeConversion(typeConverter); populateSPIRVToLLVMTypeConversion(typeConverter);
ConversionTarget target(*context); ConversionTarget target(*context);
target.addLegalDialect<LLVM::LLVMDialect>(); target.addLegalDialect<LLVM::LLVMDialect>();
Show All 15 Lines

mlir/lib/Conversion/StandardToLLVM/CMakeLists.txt

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

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

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

mlir/lib/Conversion/VectorToROCDL/CMakeLists.txt

add_mlir_conversion_library(MLIRVectorToROCDL add_mlir_conversion_library(MLIRVectorToROCDL
VectorToROCDL.cpp VectorToROCDL.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/VectorToROCDL ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/VectorToROCDL
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
intrinsics_gen intrinsics_gen
LINK_COMPONENTS LINK_COMPONENTS
Core Core
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRFuncToLLVM
MLIRROCDLIR MLIRROCDLIR
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRMemRefToLLVM MLIRMemRefToLLVM
MLIRStandardToLLVM
MLIRVector MLIRVector
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/VectorToROCDL/VectorToROCDL.cpp

//===- VectorToROCDL.cpp - Vector to ROCDL lowering passes ------===// //===- VectorToROCDL.cpp - Vector to ROCDL lowering passes ------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to generate ROCDLIR operations for higher-level // This file implements a pass to generate ROCDLIR operations for higher-level
// Vector operations. // Vector operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/VectorToROCDL/VectorToROCDL.h" #include "mlir/Conversion/VectorToROCDL/VectorToROCDL.h"
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h" #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/LLVMIR/ROCDLDialect.h" #include "mlir/Dialect/LLVMIR/ROCDLDialect.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"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 Lines
} // namespace } // namespace
void LowerVectorToROCDLPass::runOnOperation() { void LowerVectorToROCDLPass::runOnOperation() {
LLVMTypeConverter converter(&getContext()); LLVMTypeConverter converter(&getContext());
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateVectorToROCDLConversionPatterns(converter, patterns); populateVectorToROCDLConversionPatterns(converter, patterns);
populateMemRefToLLVMConversionPatterns(converter, patterns); populateMemRefToLLVMConversionPatterns(converter, patterns);
populateStdToLLVMConversionPatterns(converter, patterns); populateFuncToLLVMConversionPatterns(converter, patterns);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
target.addLegalDialect<ROCDL::ROCDLDialect>(); target.addLegalDialect<ROCDL::ROCDLDialect>();
if (failed( if (failed(
applyPartialConversion(getOperation(), target, std::move(patterns)))) applyPartialConversion(getOperation(), target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
std::unique_ptr<OperationPass<ModuleOp>> std::unique_ptr<OperationPass<ModuleOp>>
mlir::createConvertVectorToROCDLPass() { mlir::createConvertVectorToROCDLPass() {
return std::make_unique<LowerVectorToROCDLPass>(); return std::make_unique<LowerVectorToROCDLPass>();
} }

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

Show All 34 Linesadd_mlir_dialect_library(MLIRLinalgTransforms
MLIRAffineBufferizableOpInterfaceImpl MLIRAffineBufferizableOpInterfaceImpl
MLIRAffineUtils MLIRAffineUtils
MLIRAnalysis MLIRAnalysis
MLIRArithmetic MLIRArithmetic
MLIRArithmeticTransforms MLIRArithmeticTransforms
MLIRBufferization MLIRBufferization
MLIRComplex MLIRComplex
MLIRFunc MLIRFunc
MLIRFuncToLLVM
MLIRFuncTransforms MLIRFuncTransforms
MLIRInferTypeOpInterface MLIRInferTypeOpInterface
MLIRIR MLIRIR
MLIRMemRef MLIRMemRef
MLIRLinalg MLIRLinalg
MLIRLinalgAnalysis MLIRLinalgAnalysis
MLIRLinalgUtils MLIRLinalgUtils
MLIRModuleBufferization MLIRModuleBufferization
MLIRSCF MLIRSCF
MLIRSCFTransforms MLIRSCFTransforms
MLIRSCFUtils MLIRSCFUtils
MLIRPass MLIRPass
MLIRSparseTensor MLIRSparseTensor
MLIRStandardToLLVM
MLIRTensor MLIRTensor
MLIRTensorTilingInterfaceImpl MLIRTensorTilingInterfaceImpl
MLIRTensorTransforms MLIRTensorTransforms
MLIRTransforms MLIRTransforms
MLIRTransformUtils MLIRTransformUtils
MLIRVector MLIRVector
MLIRVectorTransforms MLIRVectorTransforms
MLIRVectorUtils MLIRVectorUtils
MLIRX86VectorTransforms MLIRX86VectorTransforms
MLIRVectorToSCF MLIRVectorToSCF
) )

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

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesvoid mlir::sparse_tensor::buildSparseCompiler(
pm.addPass(arith::createConstantBufferizePass()); pm.addPass(arith::createConstantBufferizePass());
pm.addNestedPass<FuncOp>(createTensorBufferizePass()); pm.addNestedPass<FuncOp>(createTensorBufferizePass());
pm.addNestedPass<FuncOp>( pm.addNestedPass<FuncOp>(
mlir::bufferization::createFinalizingBufferizePass()); mlir::bufferization::createFinalizingBufferizePass());
pm.addPass(createLowerAffinePass()); pm.addPass(createLowerAffinePass());
pm.addPass(createConvertVectorToLLVMPass(options.lowerVectorToLLVMOptions())); pm.addPass(createConvertVectorToLLVMPass(options.lowerVectorToLLVMOptions()));
pm.addPass(createMemRefToLLVMPass()); pm.addPass(createMemRefToLLVMPass());
pm.addNestedPass<FuncOp>(createConvertMathToLLVMPass()); pm.addNestedPass<FuncOp>(createConvertMathToLLVMPass());
pm.addPass(createLowerToLLVMPass()); // --convert-std-to-llvm pm.addPass(createConvertFuncToLLVMPass());
pm.addPass(createReconcileUnrealizedCastsPass()); pm.addPass(createReconcileUnrealizedCastsPass());
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Pipeline registration. // Pipeline registration.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void mlir::sparse_tensor::registerSparseTensorPipelines() { void mlir::sparse_tensor::registerSparseTensorPipelines() {
PassPipelineRegistration<SparseCompilerOptions>( PassPipelineRegistration<SparseCompilerOptions>(
"sparse-compiler", "sparse-compiler",
"The standard pipeline for taking sparsity-agnostic IR using the" "The standard pipeline for taking sparsity-agnostic IR using the"
" sparse-tensor type, and lowering it to LLVM IR with concrete" " sparse-tensor type, and lowering it to LLVM IR with concrete"
" representations and algorithms for sparse tensors.", " representations and algorithms for sparse tensors.",
buildSparseCompiler); buildSparseCompiler);
} }

mlir/lib/ExecutionEngine/CMakeLists.txt

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Linesadd_mlir_library(MLIRJitRunner
Core Core
OrcJIT OrcJIT
JITLink JITLink
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
${dialect_libs} ${dialect_libs}
MLIRExecutionEngine MLIRExecutionEngine
MLIRFunc MLIRFunc
MLIRFuncToLLVM
MLIRIR MLIRIR
MLIRParser MLIRParser
MLIRLLVMToLLVMIRTranslation MLIRLLVMToLLVMIRTranslation
MLIRTargetLLVMIRExport MLIRTargetLLVMIRExport
MLIRTransforms MLIRTransforms
MLIRStandardToLLVM
MLIRSupport MLIRSupport
) )
add_mlir_library(mlir_c_runner_utils add_mlir_library(mlir_c_runner_utils
SHARED SHARED
CRunnerUtils.cpp CRunnerUtils.cpp
SparseTensorUtils.cpp SparseTensorUtils.cpp
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

mlir/test/CAPI/execution_engine.c

Show All 21 Lines
#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("builtin.func"));
mlirPassManagerAddOwnedPass(pm, mlirCreateConversionConvertStandardToLLVM()); 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);
} }
mlirPassManagerDestroy(pm); mlirPassManagerDestroy(pm);
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-complex-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | FileCheck %s // RUN: mlir-opt %s -convert-complex-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | FileCheck %s
// CHECK-LABEL: llvm.func @complex_div // CHECK-LABEL: llvm.func @complex_div
// CHECK-SAME: %[[LHS:.*]]: ![[C_TY:.*>]], %[[RHS:.*]]: ![[C_TY]]) -> ![[C_TY]] // CHECK-SAME: %[[LHS:.*]]: ![[C_TY:.*>]], %[[RHS:.*]]: ![[C_TY]]) -> ![[C_TY]]
func @complex_div(%lhs: complex<f32>, %rhs: complex<f32>) -> complex<f32> { func @complex_div(%lhs: complex<f32>, %rhs: complex<f32>) -> complex<f32> {
%div = complex.div %lhs, %rhs : complex<f32> %div = complex.div %lhs, %rhs : complex<f32>
return %div : complex<f32> return %div : complex<f32>
} }
// CHECK: %[[LHS_RE:.*]] = llvm.extractvalue %[[LHS]][0] : ![[C_TY]] // CHECK: %[[LHS_RE:.*]] = llvm.extractvalue %[[LHS]][0] : ![[C_TY]]
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-complex-to-standard -convert-complex-to-llvm -convert-math-to-llvm -convert-arith-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | FileCheck %s // RUN: mlir-opt %s -convert-complex-to-standard -convert-complex-to-llvm -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/calling-convention.mlir

  • This file was moved from mlir/test/Conversion/StandardToLLVM/calling-convention.mlir.
// RUN: mlir-opt -convert-memref-to-llvm -convert-std-to-llvm='emit-c-wrappers=1' -reconcile-unrealized-casts %s | FileCheck %s // RUN: mlir-opt -convert-memref-to-llvm -convert-func-to-llvm='emit-c-wrappers=1' -reconcile-unrealized-casts %s | FileCheck %s
// RUN: mlir-opt -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts %s | FileCheck %s --check-prefix=EMIT_C_ATTRIBUTE // RUN: mlir-opt -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts %s | FileCheck %s --check-prefix=EMIT_C_ATTRIBUTE
// This tests the default memref calling convention and the emission of C // This tests the default memref calling convention and the emission of C
// wrappers. We don't need to separate runs because the wrapper-emission // wrappers. We don't need to separate runs because the wrapper-emission
// version subsumes the calling convention and only adds new functions, that we // version subsumes the calling convention and only adds new functions, that we
// can also file-check in the same run. // can also file-check in the same run.
// An external function is transformed into the glue around calling an interface function. // An external function is transformed into the glue around calling an interface function.
// CHECK-LABEL: @external // CHECK-LABEL: @external
▲ Show 20 Lines • Show All 238 Lines • Show Last 20 Lines

mlir/test/Conversion/FuncToLLVM/convert-argattrs.mlir

  • This file was moved from mlir/test/Conversion/StandardToLLVM/convert-argattrs.mlir.
// RUN: mlir-opt -convert-std-to-llvm %s | FileCheck %s // RUN: mlir-opt -convert-func-to-llvm %s | FileCheck %s
// CHECK-LABEL: func @check_attributes // CHECK-LABEL: func @check_attributes
// When expanding the memref to multiple arguments, argument attributes are replicated. // When expanding the memref to multiple arguments, argument attributes are replicated.
// CHECK-COUNT-7: {dialect.a = true, dialect.b = 4 : i64} // CHECK-COUNT-7: {dialect.a = true, dialect.b = 4 : i64}
func @check_attributes(%static: memref<10x20xf32> {dialect.a = true, dialect.b = 4 : i64 }) { func @check_attributes(%static: memref<10x20xf32> {dialect.a = true, dialect.b = 4 : i64 }) {
return return
} }
// CHECK-LABEL: func @check_multiple // CHECK-LABEL: func @check_multiple
// Make sure arguments attributes are attached to the right argument. We match // Make sure arguments attributes are attached to the right argument. We match
// commas in the argument list for this purpose. // commas in the argument list for this purpose.
// CHECK: %{{.*}}: !llvm{{.*}} {first.arg = true}, %{{.*}}: !llvm{{.*}} {first.arg = true}, %{{.*}}: i{{.*}} {first.arg = true}, // CHECK: %{{.*}}: !llvm{{.*}} {first.arg = true}, %{{.*}}: !llvm{{.*}} {first.arg = true}, %{{.*}}: i{{.*}} {first.arg = true},
// CHECK-SAME: %{{.*}}: !llvm{{.*}} {second.arg = 42 : i32}, %{{.*}}: !llvm{{.*}} {second.arg = 42 : i32}, %{{.*}}: i{{.*}} {second.arg = 42 : i32}) // CHECK-SAME: %{{.*}}: !llvm{{.*}} {second.arg = 42 : i32}, %{{.*}}: !llvm{{.*}} {second.arg = 42 : i32}, %{{.*}}: i{{.*}} {second.arg = 42 : i32})
func @check_multiple(%first: memref<f32> {first.arg = true}, %second: memref<f32> {second.arg = 42 : i32}) { func @check_multiple(%first: memref<f32> {first.arg = true}, %second: memref<f32> {second.arg = 42 : i32}) {
return return
} }

mlir/test/Conversion/FuncToLLVM/convert-data-layout.mlir

  • This file was added.
// RUN: mlir-opt -convert-func-to-llvm %s | FileCheck %s
// RUN-32: mlir-opt -convert-func-to-llvm='data-layout=p:32:32:32' %s | FileCheck %s
// CHECK: module attributes {llvm.data_layout = ""}
// CHECK-32: module attributes {llvm.data_layout ="p:32:32:32"}
module {}

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

  • This file was moved from mlir/test/Conversion/StandardToLLVM/convert-funcs.mlir.
// RUN: mlir-opt -convert-std-to-llvm -split-input-file -verify-diagnostics %s | FileCheck %s // RUN: mlir-opt -convert-func-to-llvm -split-input-file -verify-diagnostics %s | FileCheck %s
//CHECK: llvm.func @second_order_arg(!llvm.ptr<func<void ()>>) //CHECK: llvm.func @second_order_arg(!llvm.ptr<func<void ()>>)
func private @second_order_arg(%arg0 : () -> ()) func private @second_order_arg(%arg0 : () -> ())
//CHECK: llvm.func @second_order_result() -> !llvm.ptr<func<void ()>> //CHECK: llvm.func @second_order_result() -> !llvm.ptr<func<void ()>>
func private @second_order_result() -> (() -> ()) func private @second_order_result() -> (() -> ())
//CHECK: llvm.func @second_order_multi_result() -> !llvm.struct<(ptr<func<i32 ()>>, ptr<func<i64 ()>>, ptr<func<f32 ()>>)> //CHECK: llvm.func @second_order_multi_result() -> !llvm.struct<(ptr<func<i32 ()>>, ptr<func<i64 ()>>, ptr<func<f32 ()>>)>
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

mlir/test/Conversion/FuncToLLVM/convert-types.mlir

  • This file was moved from mlir/test/Conversion/StandardToLLVM/convert-types.mlir.
// RUN: mlir-opt -test-convert-call-op %s | FileCheck %s // RUN: mlir-opt -test-convert-call-op %s | FileCheck %s
// CHECK-LABEL: @ptr // CHECK-LABEL: @ptr
// CHECK: !llvm.ptr<i42> // CHECK: !llvm.ptr<i42>
func private @ptr() -> !llvm.ptr<!test.smpla> func private @ptr() -> !llvm.ptr<!test.smpla>
// CHECK-LABEL: @ptr_ptr() // CHECK-LABEL: @ptr_ptr()
// CHECK: !llvm.ptr<ptr<i42>> // CHECK: !llvm.ptr<ptr<i42>>
func private @ptr_ptr() -> !llvm.ptr<!llvm.ptr<!test.smpla>> func private @ptr_ptr() -> !llvm.ptr<!llvm.ptr<!test.smpla>>
// CHECK-LABEL: @struct_ptr() // CHECK-LABEL: @struct_ptr()
// CHECK: !llvm.struct<(ptr<i42>)> // CHECK: !llvm.struct<(ptr<i42>)>
func private @struct_ptr() -> !llvm.struct<(ptr<!test.smpla>)> func private @struct_ptr() -> !llvm.struct<(ptr<!test.smpla>)>
// CHECK-LABEL: @named_struct_ptr() // CHECK-LABEL: @named_struct_ptr()
// CHECK: !llvm.struct<"_Converted_named", (ptr<i42>)> // CHECK: !llvm.struct<"_Converted_named", (ptr<i42>)>
func private @named_struct_ptr() -> !llvm.struct<"named", (ptr<!test.smpla>)> func private @named_struct_ptr() -> !llvm.struct<"named", (ptr<!test.smpla>)>
// CHECK-LABEL: @named_no_convert // CHECK-LABEL: @named_no_convert
// CHECK: !llvm.struct<"no_convert", (ptr<struct<"no_convert">>)> // CHECK: !llvm.struct<"no_convert", (ptr<struct<"no_convert">>)>
func private @named_no_convert() -> !llvm.struct<"no_convert", (ptr<struct<"no_convert">>)> func private @named_no_convert() -> !llvm.struct<"no_convert", (ptr<struct<"no_convert">>)>
// CHECK-LABEL: @array_ptr() // CHECK-LABEL: @array_ptr()
// CHECK: !llvm.array<10 x ptr<i42>> // CHECK: !llvm.array<10 x ptr<i42>>
func private @array_ptr() -> !llvm.array<10 x ptr<!test.smpla>> func private @array_ptr() -> !llvm.array<10 x ptr<!test.smpla>>
// CHECK-LABEL: @func() // CHECK-LABEL: @func()
// CHECK: !llvm.ptr<func<i42 (i42)>> // CHECK: !llvm.ptr<func<i42 (i42)>>
func private @func() -> !llvm.ptr<!llvm.func<!test.smpla (!test.smpla)>> func private @func() -> !llvm.ptr<!llvm.func<!test.smpla (!test.smpla)>>
// TODO: support conversion of recursive types in the conversion infra. // TODO: support conversion of recursive types in the conversion infra.
// CHECK-LABEL: @named_recursive() // CHECK-LABEL: @named_recursive()
// CHECK: !llvm.struct<"_Converted_recursive", (ptr<i42>, ptr<struct<"_Converted_recursive">>)> // CHECK: !llvm.struct<"_Converted_recursive", (ptr<i42>, ptr<struct<"_Converted_recursive">>)>
func private @named_recursive() -> !llvm.struct<"recursive", (ptr<!test.smpla>, ptr<struct<"recursive">>)> func private @named_recursive() -> !llvm.struct<"recursive", (ptr<!test.smpla>, ptr<struct<"recursive">>)>

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

  • This file was moved from mlir/test/Conversion/StandardToLLVM/func-memref-return.mlir.
// RUN: mlir-opt -convert-std-to-llvm -reconcile-unrealized-casts %s | FileCheck %s // RUN: mlir-opt -convert-func-to-llvm -reconcile-unrealized-casts %s | FileCheck %s
// RUN: mlir-opt -convert-std-to-llvm='use-bare-ptr-memref-call-conv=1' -split-input-file %s | FileCheck %s --check-prefix=BAREPTR // RUN: mlir-opt -convert-func-to-llvm='use-bare-ptr-memref-call-conv=1' -split-input-file %s | FileCheck %s --check-prefix=BAREPTR
// These tests were separated from func-memref.mlir because applying // These tests were separated from func-memref.mlir because applying
// -reconcile-unrealized-casts resulted in `llvm.extractvalue` ops getting // -reconcile-unrealized-casts resulted in `llvm.extractvalue` ops getting
// folded away. // folded away.
// CHECK-LABEL: func @check_static_return // CHECK-LABEL: func @check_static_return
// CHECK-COUNT-2: !llvm.ptr<f32> // CHECK-COUNT-2: !llvm.ptr<f32>
// CHECK-COUNT-5: i64 // CHECK-COUNT-5: i64
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

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

  • This file was moved from mlir/test/Conversion/StandardToLLVM/func-memref.mlir.
// RUN: mlir-opt -convert-arith-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts -split-input-file %s | FileCheck %s // RUN: mlir-opt -convert-arith-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts -split-input-file %s | FileCheck %s
// RUN: mlir-opt -convert-arith-to-llvm -convert-std-to-llvm='use-bare-ptr-memref-call-conv=1' -reconcile-unrealized-casts -split-input-file %s | FileCheck %s --check-prefix=BAREPTR // RUN: mlir-opt -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

  • This file was moved from mlir/test/Conversion/StandardToLLVM/standard-to-llvm.mlir.
// RUN: mlir-opt -convert-math-to-llvm -convert-arith-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts %s -split-input-file | FileCheck %s // RUN: mlir-opt -convert-math-to-llvm -convert-arith-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts %s -split-input-file | FileCheck %s
// RUN: mlir-opt -convert-math-to-llvm -convert-arith-to-llvm='index-bitwidth=32' -convert-std-to-llvm='index-bitwidth=32' -reconcile-unrealized-casts %s -split-input-file | FileCheck --check-prefix=CHECK32 %s // RUN: mlir-opt -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/FuncToLLVM/invalid.mlir

  • This file was moved from mlir/test/Conversion/StandardToLLVM/invalid.mlir.
// RUN: mlir-opt %s -convert-std-to-llvm -verify-diagnostics -split-input-file // RUN: mlir-opt %s -convert-func-to-llvm -verify-diagnostics -split-input-file
// Should not crash on unsupported types in function signatures. // Should not crash on unsupported types in function signatures.
func private @unsupported_signature() -> tensor<10 x i32> func private @unsupported_signature() -> tensor<10 x i32>
// ----- // -----
func private @partially_supported_signature() -> (vector<10 x i32>, tensor<10 x i32>) func private @partially_supported_signature() -> (vector<10 x i32>, tensor<10 x i32>)

mlir/test/Conversion/StandardToLLVM/calling-convention.mlir

  • This file was moved to mlir/test/Conversion/FuncToLLVM/calling-convention.mlir.

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

  • This file was moved to mlir/test/Conversion/FuncToLLVM/convert-argattrs.mlir.

mlir/test/Conversion/StandardToLLVM/convert-data-layout.mlir

  • This file was deleted.
// RUN: mlir-opt -convert-std-to-llvm %s | FileCheck %s
// RUN-32: mlir-opt -convert-std-to-llvm='data-layout=p:32:32:32' %s | FileCheck %s
// CHECK: module attributes {llvm.data_layout = ""}
// CHECK-32: module attributes {llvm.data_layout ="p:32:32:32"}
module {}

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

  • This file was moved to mlir/test/Conversion/FuncToLLVM/convert-funcs.mlir.

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

  • This file was moved to mlir/test/Conversion/FuncToLLVM/convert-types.mlir.

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

  • This file was moved to mlir/test/Conversion/FuncToLLVM/func-memref-return.mlir.

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

  • This file was moved to mlir/test/Conversion/FuncToLLVM/func-memref.mlir.

mlir/test/Conversion/StandardToLLVM/invalid.mlir

  • This file was moved to mlir/test/Conversion/FuncToLLVM/invalid.mlir.

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

  • This file was moved to mlir/test/Conversion/FuncToLLVM/func-to-llvm.mlir.

mlir/test/Dialect/ArmSVE/legalize-for-llvm.mlir

// RUN: mlir-opt %s -convert-vector-to-llvm="enable-arm-sve" -convert-std-to-llvm -reconcile-unrealized-casts | mlir-opt | FileCheck %s // RUN: mlir-opt %s -convert-vector-to-llvm="enable-arm-sve" -convert-func-to-llvm -reconcile-unrealized-casts | mlir-opt | FileCheck %s
func @arm_sve_sdot(%a: vector<[16]xi8>, func @arm_sve_sdot(%a: vector<[16]xi8>,
%b: vector<[16]xi8>, %b: vector<[16]xi8>,
%c: vector<[4]xi32>) %c: vector<[4]xi32>)
-> vector<[4]xi32> { -> vector<[4]xi32> {
// CHECK: arm_sve.intr.sdot // CHECK: arm_sve.intr.sdot
%0 = arm_sve.sdot %c, %a, %b : %0 = arm_sve.sdot %c, %a, %b :
vector<[16]xi8> to vector<[4]xi32> vector<[16]xi8> to vector<[4]xi32>
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

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

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

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

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

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

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

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

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

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

// RUN: export M=24 && export K=64 && export N=192 && export ITERS=10 && \ // RUN: export M=24 && export K=64 && export N=192 && export ITERS=10 && \
// RUN: cat %s | sed 's@${M}@'"$M"'@g'| sed 's@${K}@'"$K"'@g' | sed 's@${N}@'"$N"'@g'| sed 's@${ITERS}@'"$ITERS"'@g'| \ // RUN: cat %s | sed 's@${M}@'"$M"'@g'| sed 's@${K}@'"$K"'@g' | sed 's@${N}@'"$N"'@g'| sed 's@${ITERS}@'"$ITERS"'@g'| \
// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul register-tile-sizes=12,32,16 vectorize" | \ // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul register-tile-sizes=12,32,16 vectorize" | \
// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.fill register-tile-sizes=4,32 vectorize" | \ // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.fill register-tile-sizes=4,32 vectorize" | \
// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=memref.copy register-tile-sizes=4,32 vectorize" | \ // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=memref.copy register-tile-sizes=4,32 vectorize" | \
// RUN: mlir-opt -canonicalize -convert-vector-to-scf -lower-affine -convert-linalg-to-loops | \ // RUN: mlir-opt -canonicalize -convert-vector-to-scf -lower-affine -convert-linalg-to-loops | \
// RUN: mlir-opt -canonicalize -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt -canonicalize -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-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/matmul-vs-matvec.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-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 \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(memref<*xf32>)
func @matmul(%A: memref<?x?xf32>, %B: memref<?x?xf32>) -> (memref<?x?xf32>) { func @matmul(%A: memref<?x?xf32>, %B: memref<?x?xf32>) -> (memref<?x?xf32>) {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

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

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

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

// RUN: mlir-opt %s -linalg-bufferize \ // RUN: mlir-opt %s -linalg-bufferize \
// RUN: -arith-bufferize -tensor-bufferize -func-bufferize \ // RUN: -arith-bufferize -tensor-bufferize -func-bufferize \
// RUN: -finalizing-bufferize -buffer-deallocation -convert-linalg-to-llvm \ // RUN: -finalizing-bufferize -buffer-deallocation -convert-linalg-to-llvm \
// RUN: -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -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
func @main() { func @main() {
%const = arith.constant dense<[[[[-3.9058,0.9072],[-2.9470,-2.2055],[18.3946,8.2997]],[[3.4700,5.9006],[-17.2267,4.9777],[1.0450,-0.8201]]],[[[17.6996,-11.1763],[26.7775,-3.8823],[-4.2492,-5.8966]],[[2.1259,13.1794],[-10.7136,0.8428],[16.4233,9.4589]]]]> : tensor<2x2x3x2xf32> %const = arith.constant dense<[[[[-3.9058,0.9072],[-2.9470,-2.2055],[18.3946,8.2997]],[[3.4700,5.9006],[-17.2267,4.9777],[1.0450,-0.8201]]],[[[17.6996,-11.1763],[26.7775,-3.8823],[-4.2492,-5.8966]],[[2.1259,13.1794],[-10.7136,0.8428],[16.4233,9.4589]]]]> : tensor<2x2x3x2xf32>
%dynamic = tensor.cast %const: tensor<2x2x3x2xf32> to tensor<2x?x?x?xf32> %dynamic = tensor.cast %const: tensor<2x2x3x2xf32> to tensor<2x?x?x?xf32>
Show All 26 Lines

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// RUN: mlir-opt %s -convert-elementwise-to-linalg \ // RUN: mlir-opt %s -convert-elementwise-to-linalg \
// RUN: -arith-bufferize -linalg-bufferize -tensor-bufferize \ // RUN: -arith-bufferize -linalg-bufferize -tensor-bufferize \
// RUN: -func-bufferize -buffer-deallocation -convert-linalg-to-loops \ // RUN: -func-bufferize -buffer-deallocation -convert-linalg-to-loops \
// RUN: -convert-linalg-to-llvm --convert-memref-to-llvm -convert-std-to-llvm \ // RUN: -convert-linalg-to-llvm --convert-memref-to-llvm -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts | \ // RUN: -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @main() { func @main() {
%a = arith.constant dense<[1.0, 2.0, 3.0]> : tensor<3xf32> %a = arith.constant dense<[1.0, 2.0, 3.0]> : tensor<3xf32>
%b = arith.constant dense<[10.0, 20.0, 30.0]> : tensor<3xf32> %b = arith.constant dense<[10.0, 20.0, 30.0]> : tensor<3xf32>
Show All 11 Lines

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

// RUN: mlir-opt %s -linalg-bufferize \ // RUN: mlir-opt %s -linalg-bufferize \
// RUN: -arith-bufferize -tensor-bufferize -func-bufferize \ // RUN: -arith-bufferize -tensor-bufferize -func-bufferize \
// RUN: -finalizing-bufferize -buffer-deallocation -convert-linalg-to-llvm \ // RUN: -finalizing-bufferize -buffer-deallocation -convert-linalg-to-llvm \
// RUN: -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -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
func @main() { func @main() {
%const = arith.constant dense<[[[-3.9058,0.9072],[-2.9470,-2.2055],[18.3946,8.2997],[3.4700,5.9006],[-17.2267,4.9777],[1.0450,-0.8201]],[[17.6996,-11.1763],[26.7775,-3.8823],[-4.2492,-5.8966],[2.1259,13.1794],[-10.7136,0.8428],[16.4233,9.4589]]]> : tensor<2x6x2xf32> %const = arith.constant dense<[[[-3.9058,0.9072],[-2.9470,-2.2055],[18.3946,8.2997],[3.4700,5.9006],[-17.2267,4.9777],[1.0450,-0.8201]],[[17.6996,-11.1763],[26.7775,-3.8823],[-4.2492,-5.8966],[2.1259,13.1794],[-10.7136,0.8428],[16.4233,9.4589]]]> : tensor<2x6x2xf32>
%dynamic = tensor.cast %const: tensor<2x6x2xf32> to tensor<2x?x?xf32> %dynamic = tensor.cast %const: tensor<2x6x2xf32> to tensor<2x?x?xf32>
Show All 27 Lines

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

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

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

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

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

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

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

// RUN: mlir-opt %s -arith-bufferize -linalg-bufferize \ // RUN: mlir-opt %s -arith-bufferize -linalg-bufferize \
// RUN: -tensor-bufferize -func-bufferize -finalizing-bufferize -buffer-deallocation -convert-linalg-to-loops \ // RUN: -tensor-bufferize -func-bufferize -finalizing-bufferize -buffer-deallocation -convert-linalg-to-loops \
// RUN: -convert-linalg-to-llvm --convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @foo() -> tensor<4xf32> { func @foo() -> tensor<4xf32> {
%0 = arith.constant dense<[1.0, 2.0, 3.0, 4.0]> : tensor<4xf32> %0 = arith.constant dense<[1.0, 2.0, 3.0, 4.0]> : tensor<4xf32>
return %0 : tensor<4xf32> return %0 : tensor<4xf32>
} }
Show All 25 Lines

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

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

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

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

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

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

mlir/test/Integration/Dialect/Standard/CPU/test_subview.mlir

// RUN: mlir-opt %s -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -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 | FileCheck %s // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext | FileCheck %s
memref.global "private" constant @__constant_5x3xf32 : memref<5x3xf32> = memref.global "private" constant @__constant_5x3xf32 : memref<5x3xf32> =
dense<[[0.0, 1.0, 2.0], dense<[[0.0, 1.0, 2.0],
[3.0, 4.0, 5.0], [3.0, 4.0, 5.0],
[6.0, 7.0, 8.0], [6.0, 7.0, 8.0],
[9.0, 10.0, 11.0], [9.0, 10.0, 11.0],
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// RUN: mlir-opt %s -convert-vector-to-llvm="enable-x86vector" -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-llvm="enable-x86vector" -convert-func-to-llvm | \
// RUN: mlir-translate --mlir-to-llvmir | \ // RUN: mlir-translate --mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="avx" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="avx" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() -> i32 { func @entry() -> i32 {
%i0 = arith.constant 0 : i32 %i0 = arith.constant 0 : i32
%v = arith.constant dense<[0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0]> : vector<8xf32> %v = arith.constant dense<[0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0]> : vector<8xf32>
%r = x86vector.avx.rsqrt %v : vector<8xf32> %r = x86vector.avx.rsqrt %v : vector<8xf32>
// `rsqrt` may produce slightly different results on Intel and AMD machines: accept both results here. // `rsqrt` may produce slightly different results on Intel and AMD machines: accept both results here.
// CHECK: {{( 2.82[0-9]*, 1.99[0-9]*, 1.41[0-9]*, 0.99[0-9]*, 0.70[0-9]*, 0.49[0-9]*, 0.35[0-9]*, 0.24[0-9]* )}} // CHECK: {{( 2.82[0-9]*, 1.99[0-9]*, 1.41[0-9]*, 0.99[0-9]*, 0.70[0-9]*, 0.49[0-9]*, 0.35[0-9]*, 0.24[0-9]* )}}
vector.print %r : vector<8xf32> vector.print %r : vector<8xf32>
return %i0 : i32 return %i0 : i32
} }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

mlir/test/Integration/Dialect/Vector/CPU/test-index-vectors.mlir

// RUN: mlir-opt %s -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-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 @entry() { func @entry() {
%c0 = arith.constant dense<[0, 1, 2, 3]>: vector<4xindex> %c0 = arith.constant dense<[0, 1, 2, 3]>: vector<4xindex>
%c1 = arith.constant dense<[0, 1]>: vector<2xindex> %c1 = arith.constant dense<[0, 1]>: vector<2xindex>
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
Show All 23 Lines

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// RUN: mlir-opt %s -convert-scf-to-cf \ // RUN: mlir-opt %s -convert-scf-to-cf \
// RUN: -convert-vector-to-llvm='reassociate-fp-reductions' \ // RUN: -convert-vector-to-llvm='reassociate-fp-reductions' \
// RUN: -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-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 @entry() { func @entry() {
// Construct test vector, numerically very stable. // Construct test vector, numerically very stable.
%f1 = arith.constant 1.0: f32 %f1 = arith.constant 1.0: f32
%f2 = arith.constant 2.0: f32 %f2 = arith.constant 2.0: f32
Show All 27 Lines

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

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

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

// RUN: mlir-opt %s -convert-scf-to-cf \ // RUN: mlir-opt %s -convert-scf-to-cf \
// RUN: -convert-vector-to-llvm='reassociate-fp-reductions' \ // RUN: -convert-vector-to-llvm='reassociate-fp-reductions' \
// RUN: -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-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 @entry() { func @entry() {
// Construct test vector, numerically very stable. // Construct test vector, numerically very stable.
%f1 = arith.constant 1.0: f64 %f1 = arith.constant 1.0: f64
%f2 = arith.constant 2.0: f64 %f2 = arith.constant 2.0: f64
Show All 27 Lines

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-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 -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-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 -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -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 -convert-vector-to-scf='full-unroll=true lower-permutation-maps=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true lower-permutation-maps=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-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 -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -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 -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-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 -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -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 -convert-vector-to-scf='full-unroll=true lower-permutation-maps=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true lower-permutation-maps=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-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 -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -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 -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-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 -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -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 -convert-vector-to-scf='full-unroll=true lower-permutation-maps=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true lower-permutation-maps=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-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 -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -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 -convert-vector-to-scf=full-unroll=true -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -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 -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -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 -convert-vector-to-scf=full-unroll=true -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -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-transfer-write.mlir

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

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

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

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

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

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

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

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

// RUN: mlir-opt %s -convert-vector-to-llvm -convert-arith-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-translate -mlir-to-llvmir | FileCheck %s // RUN: mlir-opt %s -convert-vector-to-llvm -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/lib/Conversion/CMakeLists.txt

add_subdirectory(StandardToLLVM) add_subdirectory(FuncToLLVM)

mlir/test/lib/Conversion/FuncToLLVM/CMakeLists.txt

  • This file was moved from mlir/test/lib/Conversion/StandardToLLVM/CMakeLists.txt.
# Exclude tests from libMLIR.so # Exclude tests from libMLIR.so
add_mlir_library(MLIRTestStandardToLLVM add_mlir_library(MLIRTestFuncToLLVM
TestConvertCallOp.cpp TestConvertCallOp.cpp
EXCLUDE_FROM_LIBMLIR EXCLUDE_FROM_LIBMLIR
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRFuncToLLVM
MLIRLLVMCommonConversion MLIRLLVMCommonConversion
MLIRLLVMIR MLIRLLVMIR
MLIRLLVMIRTransforms MLIRLLVMIRTransforms
MLIRPass MLIRPass
MLIRStandardToLLVM
MLIRTestDialect MLIRTestDialect
) )
target_include_directories(MLIRTestStandardToLLVM target_include_directories(MLIRTestFuncToLLVM
PRIVATE PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/../../Dialect/Test ${CMAKE_CURRENT_SOURCE_DIR}/../../Dialect/Test
${CMAKE_CURRENT_BINARY_DIR}/../../Dialect/Test ${CMAKE_CURRENT_BINARY_DIR}/../../Dialect/Test
) )

mlir/test/lib/Conversion/FuncToLLVM/TestConvertCallOp.cpp

  • This file was moved from mlir/test/lib/Conversion/StandardToLLVM/TestConvertCallOp.cpp.
//===- TestConvertCallOp.cpp - Test LLVM Conversion of Standard CallOp ----===// //===- TestConvertCallOp.cpp - Test LLVM Conversion of Func CallOp --------===//
// //
// 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 "TestTypes.h" #include "TestTypes.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h" #include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
Show All 32 Lines typeConverter.addConversion([&](test::TestType type) {
return LLVM::LLVMPointerType::get(IntegerType::get(m.getContext(), 8)); return LLVM::LLVMPointerType::get(IntegerType::get(m.getContext(), 8));
}); });
typeConverter.addConversion([&](test::SimpleAType type) { typeConverter.addConversion([&](test::SimpleAType type) {
return IntegerType::get(type.getContext(), 42); return IntegerType::get(type.getContext(), 42);
}); });
// Populate patterns. // Populate patterns.
RewritePatternSet patterns(m.getContext()); RewritePatternSet patterns(m.getContext());
populateStdToLLVMConversionPatterns(typeConverter, patterns); populateFuncToLLVMConversionPatterns(typeConverter, patterns);
patterns.add<TestTypeProducerOpConverter>(typeConverter); patterns.add<TestTypeProducerOpConverter>(typeConverter);
// Set target. // Set target.
ConversionTarget target(getContext()); ConversionTarget target(getContext());
target.addLegalDialect<LLVM::LLVMDialect>(); target.addLegalDialect<LLVM::LLVMDialect>();
target.addIllegalDialect<test::TestDialect>(); target.addIllegalDialect<test::TestDialect>();
target.addIllegalDialect<func::FuncDialect>(); target.addIllegalDialect<func::FuncDialect>();
Show All 12 Lines

mlir/test/lib/Conversion/StandardToLLVM/CMakeLists.txt

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

mlir/test/lib/Conversion/StandardToLLVM/TestConvertCallOp.cpp

  • This file was moved to mlir/test/lib/Conversion/FuncToLLVM/TestConvertCallOp.cpp.

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

// RUN: mlir-opt %s -test-math-polynomial-approximation="enable-avx2" \ // RUN: mlir-opt %s -test-math-polynomial-approximation="enable-avx2" \
// RUN: -convert-arith-to-llvm \ // RUN: -convert-arith-to-llvm \
// RUN: -convert-vector-to-llvm="enable-x86vector" \ // RUN: -convert-vector-to-llvm="enable-x86vector" \
// RUN: -convert-math-to-llvm \ // RUN: -convert-math-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e main -entry-point-result=void -O0 \ // RUN: -e main -entry-point-result=void -O0 \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \
// 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
// -------------------------------------------------------------------------- // // -------------------------------------------------------------------------- //
Show All 27 Lines

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

// RUN: mlir-opt %s -async-to-async-runtime \ // RUN: mlir-opt %s -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-linalg-to-loops \ // RUN: -convert-linalg-to-loops \
// RUN: -convert-scf-to-cf \ // RUN: -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm \ // RUN: -convert-linalg-to-llvm \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-arith-to-llvm \ // RUN: -convert-arith-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e main -entry-point-result=void -O0 \ // RUN: -e main -entry-point-result=void -O0 \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \
// 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
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -async-to-async-runtime \ // RUN: mlir-opt %s -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-arith-to-llvm \ // RUN: -convert-arith-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e main -entry-point-result=void -O0 \ // RUN: -e main -entry-point-result=void -O0 \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \
// 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
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -async-to-async-runtime \ // RUN: mlir-opt %s -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-arith-to-llvm \ // RUN: -convert-arith-to-llvm \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e main -entry-point-result=void -O0 \ // RUN: -e main -entry-point-result=void -O0 \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \
// 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
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -async-to-async-runtime \ // RUN: mlir-opt %s -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-linalg-to-loops \ // RUN: -convert-linalg-to-loops \
// RUN: -convert-scf-to-cf \ // RUN: -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm \ // RUN: -convert-linalg-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-arith-to-llvm \ // RUN: -convert-arith-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e main -entry-point-result=void -O0 \ // RUN: -e main -entry-point-result=void -O0 \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \
// 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
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-scf-to-cf -convert-arith-to-llvm -convert-memref-to-llvm -convert-std-to-llvm='use-bare-ptr-memref-call-conv=1' -reconcile-unrealized-casts | mlir-cpu-runner -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext -entry-point-result=void | FileCheck %s // RUN: mlir-opt %s -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 -convert-scf-to-cf -convert-arith-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-arith-to-llvm -convert-memref-to-llvm -convert-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 -convert-arith-to-llvm -convert-memref-to-llvm -convert-std-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 -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 -test-math-polynomial-approximation \ // RUN: mlir-opt %s -test-math-polynomial-approximation \
// RUN: -convert-arith-to-llvm \ // RUN: -convert-arith-to-llvm \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-math-to-llvm \ // RUN: -convert-math-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e main -entry-point-result=void -O0 \ // RUN: -e main -entry-point-result=void -O0 \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \
// 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
// -------------------------------------------------------------------------- // // -------------------------------------------------------------------------- //
▲ Show 20 Lines • Show All 506 Lines • Show Last 20 Lines

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

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

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

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-arith-to-llvm -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e print_0d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-0D // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-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 -convert-linalg-to-loops -convert-scf-to-cf -convert-arith-to-llvm -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e print_1d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-1D // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-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 -convert-linalg-to-loops -convert-scf-to-cf -convert-arith-to-llvm -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e print_3d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-3D // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-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 -convert-linalg-to-loops -convert-scf-to-cf -convert-arith-to-llvm -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e vector_splat_2d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-VECTOR-SPLAT-2D // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-arith-to-llvm -convert-linalg-to-llvm -convert-memref-to-llvm -convert-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-opt/async.mlir

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

mlir/test/python/execution_engine.py

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
run(testInvalidModule) run(testInvalidModule)
def lowerToLLVM(module): def lowerToLLVM(module):
import mlir.conversions import mlir.conversions
pm = PassManager.parse( pm = PassManager.parse(
"convert-memref-to-llvm,convert-std-to-llvm,reconcile-unrealized-casts") "convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts")
pm.run(module) pm.run(module)
return module return module
# Test simple ExecutionEngine execution # Test simple ExecutionEngine execution
# CHECK-LABEL: TEST: testInvokeVoid # CHECK-LABEL: TEST: testInvokeVoid
def testInvokeVoid(): def testInvokeVoid():
with Context(): with Context():
▲ Show 20 Lines • Show All 319 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 192 Lines • ▼ Show 20 Linesdef transform(module, boilerplate):
# TODO: Allow cloning functions from one module to another. # TODO: Allow cloning functions from one module to another.
# Atm we have to resort to string concatenation. # Atm we have to resort to string concatenation.
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, " + "builtin.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-std-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()
▲ Show 20 Lines • Show All 402 Lines • Show Last 20 Lines

mlir/tools/mlir-opt/CMakeLists.txt

set(LLVM_OPTIONAL_SOURCES set(LLVM_OPTIONAL_SOURCES
null.cpp null.cpp
) )
get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS) get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS) get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
set(LLVM_LINK_COMPONENTS set(LLVM_LINK_COMPONENTS
Core Core
Support Support
AsmParser AsmParser
) )
if(MLIR_INCLUDE_TESTS) if(MLIR_INCLUDE_TESTS)
set(test_libs set(test_libs
MLIRTestStandardToLLVM MLIRTestFuncToLLVM
MLIRAffineTransformsTestPasses MLIRAffineTransformsTestPasses
MLIRDLTITestPasses MLIRDLTITestPasses
MLIRFuncTestPasses MLIRFuncTestPasses
MLIRGPUTestPasses MLIRGPUTestPasses
MLIRLinalgTestPasses MLIRLinalgTestPasses
MLIRMathTestPasses MLIRMathTestPasses
MLIRMemRefTestPasses MLIRMemRefTestPasses
MLIRSCFTestPasses MLIRSCFTestPasses
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

mlir/tools/mlir-spirv-cpu-runner/mlir-spirv-cpu-runner.cpp

//===- mlir-spirv-cpu-runner.cpp - MLIR SPIR-V Execution on CPU -----------===// //===- mlir-spirv-cpu-runner.cpp - MLIR SPIR-V Execution on CPU -----------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Main entry point to a command line utility that executes an MLIR file on the // Main entry point to a command line utility that executes an MLIR file on the
// CPU by translating MLIR GPU module and host part to LLVM IR before // CPU by translating MLIR GPU module and host part to LLVM IR before
// JIT-compiling and executing. // JIT-compiling and executing.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h" #include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h"
#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h" #include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.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/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/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/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"
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

mlir/tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp

//===- mlir-vulkan-runner.cpp - MLIR Vulkan Execution Driver --------------===// //===- mlir-vulkan-runner.cpp - MLIR Vulkan Execution Driver --------------===//
// //
// 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 is a command line utility that executes an MLIR file on the Vulkan by // This is a command line utility that executes an MLIR file on the Vulkan by
// translating MLIR GPU module to SPIR-V and host part to LLVM IR before // translating MLIR GPU module to SPIR-V and host part to LLVM IR before
// JIT-compiling and executing the latter. // JIT-compiling and executing the latter.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRVPass.h" #include "mlir/Conversion/FuncToSPIRV/FuncToSPIRVPass.h"
#include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h" #include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h"
#include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h" #include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
#include "mlir/Conversion/LLVMCommon/LoweringOptions.h" #include "mlir/Conversion/LLVMCommon/LoweringOptions.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/StandardToLLVM/ConvertStandardToLLVMPass.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/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/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/MemRef/Transforms/Passes.h" #include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
Show All 19 Linesstatic LogicalResult runMLIRPasses(ModuleOp module) {
passManager.addPass(createConvertGPUToSPIRVPass()); passManager.addPass(createConvertGPUToSPIRVPass());
OpPassManager &modulePM = passManager.nest<spirv::ModuleOp>(); OpPassManager &modulePM = passManager.nest<spirv::ModuleOp>();
modulePM.addPass(spirv::createLowerABIAttributesPass()); modulePM.addPass(spirv::createLowerABIAttributesPass());
modulePM.addPass(spirv::createUpdateVersionCapabilityExtensionPass()); modulePM.addPass(spirv::createUpdateVersionCapabilityExtensionPass());
passManager.addPass(createConvertGpuLaunchFuncToVulkanLaunchFuncPass()); passManager.addPass(createConvertGpuLaunchFuncToVulkanLaunchFuncPass());
LowerToLLVMOptions llvmOptions(module.getContext(), DataLayout(module)); LowerToLLVMOptions llvmOptions(module.getContext(), DataLayout(module));
llvmOptions.emitCWrappers = true; llvmOptions.emitCWrappers = true;
passManager.addPass(createMemRefToLLVMPass()); passManager.addPass(createMemRefToLLVMPass());
passManager.addPass(createLowerToLLVMPass(llvmOptions)); passManager.addPass(createConvertFuncToLLVMPass(llvmOptions));
passManager.addPass(createReconcileUnrealizedCastsPass()); passManager.addPass(createReconcileUnrealizedCastsPass());
passManager.addPass(createConvertVulkanLaunchFuncToVulkanCallsPass()); passManager.addPass(createConvertVulkanLaunchFuncToVulkanCallsPass());
return passManager.run(module); return passManager.run(module);
} }
int main(int argc, char **argv) { int main(int argc, char **argv) {
llvm::llvm_shutdown_obj x; llvm::llvm_shutdown_obj x;
registerPassManagerCLOptions(); registerPassManagerCLOptions();
Show All 17 Lines

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/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/StandardToLLVM/ConvertStandardToLLVMPass.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/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"
Show All 20 Lines
} initializer; } initializer;
/// Simple conversion pipeline for the purpose of testing sources written in /// Simple conversion pipeline for the purpose of testing sources written in
/// dialects lowering to LLVM Dialect. /// dialects lowering to LLVM Dialect.
static LogicalResult lowerToLLVMDialect(ModuleOp module) { static LogicalResult lowerToLLVMDialect(ModuleOp module) {
PassManager pm(module.getContext()); PassManager pm(module.getContext());
pm.addPass(mlir::createMemRefToLLVMPass()); pm.addPass(mlir::createMemRefToLLVMPass());
pm.addNestedPass<FuncOp>(mlir::arith::createConvertArithmeticToLLVMPass()); pm.addNestedPass<FuncOp>(mlir::arith::createConvertArithmeticToLLVMPass());
pm.addPass(mlir::createLowerToLLVMPass()); pm.addPass(mlir::createConvertFuncToLLVMPass());
pm.addPass(mlir::createReconcileUnrealizedCastsPass()); pm.addPass(mlir::createReconcileUnrealizedCastsPass());
return pm.run(module); return pm.run(module);
} }
TEST(MLIRExecutionEngine, AddInteger) { TEST(MLIRExecutionEngine, AddInteger) {
std::string moduleStr = R"mlir( std::string moduleStr = R"mlir(
func @foo(%arg0 : i32) -> i32 attributes { llvm.emit_c_interface } { func @foo(%arg0 : i32) -> i32 attributes { llvm.emit_c_interface } {
%res = arith.addi %arg0, %arg0 : i32 %res = arith.addi %arg0, %arg0 : i32
▲ Show 20 Lines • Show All 216 Lines • Show Last 20 Lines
mlir/test/Conversion/FuncToLLVM/invalid.mlir