1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
|
//===- TestLowerToLLVM.cpp - Test lowering to LLVM as a sink pass ---------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements a pass for testing the lowering to LLVM as a generally
// usable sink pass.
//
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/IndexToLLVM/IndexToLLVM.h"
#include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
#include "mlir/Conversion/MathToLLVM/MathToLLVM.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
#include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/IR/DialectRegistry.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Pass/PassManager.h"
#include "mlir/Pass/PassOptions.h"
#include "mlir/Transforms/Passes.h"
using namespace mlir;
namespace {
struct TestLowerToLLVMOptions
: public PassPipelineOptions<TestLowerToLLVMOptions> {
PassOptions::Option<bool> reassociateFPReductions{
*this, "reassociate-fp-reductions",
llvm::cl::desc("Allow reassociation og FP reductions"),
llvm::cl::init(false)};
};
void buildTestLowerToLLVM(OpPassManager &pm,
const TestLowerToLLVMOptions &options) {
// TODO: it is feasible to scope lowering at arbitrary level and introduce
// unrealized casts, but there needs to be the final module-wise cleanup in
// the end. Keep module-level for now.
auto enableOpaquePointers = [](auto options) {
options.useOpaquePointers = true;
return options;
};
// Blanket-convert any remaining high-level vector ops to loops if any remain.
pm.addNestedPass<func::FuncOp>(createConvertVectorToSCFPass());
// Blanket-convert any remaining linalg ops to loops if any remain.
pm.addNestedPass<func::FuncOp>(createConvertLinalgToLoopsPass());
// Blanket-convert any remaining affine ops if any remain.
pm.addPass(createLowerAffinePass());
// Convert SCF to CF (always needed).
pm.addPass(createConvertSCFToCFPass());
// Sprinkle some cleanups.
pm.addPass(createCanonicalizerPass());
pm.addPass(createCSEPass());
// Blanket-convert any remaining linalg ops to LLVM if any remain.
pm.addPass(createConvertLinalgToLLVMPass());
// Convert vector to LLVM (always needed).
pm.addPass(createConvertVectorToLLVMPass(
// TODO: add more options on a per-need basis.
enableOpaquePointers(
ConvertVectorToLLVMPassOptions{options.reassociateFPReductions})));
// Convert Math to LLVM (always needed).
pm.addNestedPass<func::FuncOp>(createConvertMathToLLVMPass());
// Expand complicated MemRef operations before lowering them.
pm.addPass(memref::createExpandStridedMetadataPass());
// The expansion may create affine expressions. Get rid of them.
pm.addPass(createLowerAffinePass());
// Convert MemRef to LLVM (always needed).
pm.addPass(createFinalizeMemRefToLLVMConversionPass(
enableOpaquePointers(FinalizeMemRefToLLVMConversionPassOptions{})));
// Convert Func to LLVM (always needed).
pm.addPass(createConvertFuncToLLVMPass(
enableOpaquePointers(ConvertFuncToLLVMPassOptions{})));
// Convert Index to LLVM (always needed).
pm.addPass(createConvertIndexToLLVMPass());
// Convert remaining unrealized_casts (always needed).
pm.addPass(createReconcileUnrealizedCastsPass());
}
} // namespace
namespace mlir {
namespace test {
void registerTestLowerToLLVM() {
PassPipelineRegistration<TestLowerToLLVMOptions>(
"test-lower-to-llvm",
"An example of pipeline to lower the main dialects (arith, linalg, "
"memref, scf, vector) down to LLVM.",
buildTestLowerToLLVM);
}
} // namespace test
} // namespace mlir
|
