MLIR 23.0.0git
ComplexToSPIRV.cpp
Go to the documentation of this file.
1//===- ComplexToSPIRV.cpp - Complex to SPIR-V Patterns --------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements patterns to convert Complex dialect to SPIR-V dialect.
10//
11//===----------------------------------------------------------------------===//
12
13#include "mlir/Conversion/ComplexToSPIRV/ComplexToSPIRV.h"
14#include "mlir/Dialect/Complex/IR/Complex.h"
15#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
16#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
17#include "mlir/Transforms/DialectConversion.h"
18
19#define DEBUG_TYPE "complex-to-spirv-pattern"
20
21using namespace mlir;
22
23//===----------------------------------------------------------------------===//
24// Operation conversion
25//===----------------------------------------------------------------------===//
26
27namespace {
28
29struct ConstantOpPattern final : OpConversionPattern<complex::ConstantOp> {
30 using Base::Base;
31
32 LogicalResult
33 matchAndRewrite(complex::ConstantOp constOp, OpAdaptor adaptor,
34 ConversionPatternRewriter &rewriter) const override {
35 auto spirvType =
36 getTypeConverter()->convertType<ShapedType>(constOp.getType());
37 if (!spirvType)
38 return rewriter.notifyMatchFailure(constOp,
39 "unable to convert result type");
40
41 rewriter.replaceOpWithNewOp<spirv::ConstantOp>(
42 constOp, spirvType,
43 DenseElementsAttr::get(spirvType, constOp.getValue().getValue()));
44 return success();
45 }
46};
47
48struct CreateOpPattern final : OpConversionPattern<complex::CreateOp> {
49 using Base::Base;
50
51 LogicalResult
52 matchAndRewrite(complex::CreateOp createOp, OpAdaptor adaptor,
53 ConversionPatternRewriter &rewriter) const override {
54 Type spirvType = getTypeConverter()->convertType(createOp.getType());
55 if (!spirvType)
56 return rewriter.notifyMatchFailure(createOp,
57 "unable to convert result type");
58
59 rewriter.replaceOpWithNewOp<spirv::CompositeConstructOp>(
60 createOp, spirvType, adaptor.getOperands());
61 return success();
62 }
63};
64
65struct ReOpPattern final : OpConversionPattern<complex::ReOp> {
66 using Base::Base;
67
68 LogicalResult
69 matchAndRewrite(complex::ReOp reOp, OpAdaptor adaptor,
70 ConversionPatternRewriter &rewriter) const override {
71 Type spirvType = getTypeConverter()->convertType(reOp.getType());
72 if (!spirvType)
73 return rewriter.notifyMatchFailure(reOp, "unable to convert result type");
74
75 rewriter.replaceOpWithNewOp<spirv::CompositeExtractOp>(
76 reOp, adaptor.getComplex(), llvm::ArrayRef(0));
77 return success();
78 }
79};
80
81struct ImOpPattern final : OpConversionPattern<complex::ImOp> {
82 using Base::Base;
83
84 LogicalResult
85 matchAndRewrite(complex::ImOp imOp, OpAdaptor adaptor,
86 ConversionPatternRewriter &rewriter) const override {
87 Type spirvType = getTypeConverter()->convertType(imOp.getType());
88 if (!spirvType)
89 return rewriter.notifyMatchFailure(imOp, "unable to convert result type");
90
91 rewriter.replaceOpWithNewOp<spirv::CompositeExtractOp>(
92 imOp, adaptor.getComplex(), llvm::ArrayRef(1));
93 return success();
94 }
95};
96
97template <typename ComplexOp, typename SPIRVOp>
98struct ElementwiseBinaryOpPattern final : OpConversionPattern<ComplexOp> {
99 using OpConversionPattern<ComplexOp>::OpConversionPattern;
100 using OpAdaptor = typename ComplexOp::Adaptor;
101
102 LogicalResult
103 matchAndRewrite(ComplexOp op, OpAdaptor adaptor,
104 ConversionPatternRewriter &rewriter) const override {
105 Type spirvType =
106 this->getTypeConverter()->convertType(op.getResult().getType());
107 if (!spirvType)
108 return rewriter.notifyMatchFailure(op, "unable to convert result type");
109
110 Location loc = op.getLoc();
111 Value lhs = adaptor.getLhs();
112 Value rhs = adaptor.getRhs();
113
114 Value lhsRe = spirv::CompositeExtractOp::create(rewriter, loc, lhs, {0});
115 Value lhsIm = spirv::CompositeExtractOp::create(rewriter, loc, lhs, {1});
116 Value rhsRe = spirv::CompositeExtractOp::create(rewriter, loc, rhs, {0});
117 Value rhsIm = spirv::CompositeExtractOp::create(rewriter, loc, rhs, {1});
118
119 Value resultRe = SPIRVOp::create(rewriter, loc, lhsRe, rhsRe);
120 Value resultIm = SPIRVOp::create(rewriter, loc, lhsIm, rhsIm);
121
122 rewriter.replaceOpWithNewOp<spirv::CompositeConstructOp>(
123 op, spirvType, llvm::ArrayRef<Value>{resultRe, resultIm});
124 return success();
125 }
126};
127
128struct MulOpPattern final : OpConversionPattern<complex::MulOp> {
129 using Base::Base;
130
131 LogicalResult
132 matchAndRewrite(complex::MulOp op, OpAdaptor adaptor,
133 ConversionPatternRewriter &rewriter) const override {
134 Type spirvType = getTypeConverter()->convertType(op.getResult().getType());
135 if (!spirvType)
136 return rewriter.notifyMatchFailure(op, "unable to convert result type");
137
138 Location loc = op.getLoc();
139 Value lhs = adaptor.getLhs();
140 Value rhs = adaptor.getRhs();
141
142 Value a = spirv::CompositeExtractOp::create(rewriter, loc, lhs, {0});
143 Value b = spirv::CompositeExtractOp::create(rewriter, loc, lhs, {1});
144 Value c = spirv::CompositeExtractOp::create(rewriter, loc, rhs, {0});
145 Value d = spirv::CompositeExtractOp::create(rewriter, loc, rhs, {1});
146
147 Value ac = spirv::FMulOp::create(rewriter, loc, a, c);
148 Value bd = spirv::FMulOp::create(rewriter, loc, b, d);
149 Value ad = spirv::FMulOp::create(rewriter, loc, a, d);
150 Value bc = spirv::FMulOp::create(rewriter, loc, b, c);
151 Value resultRe = spirv::FSubOp::create(rewriter, loc, ac, bd);
152 Value resultIm = spirv::FAddOp::create(rewriter, loc, ad, bc);
153
154 rewriter.replaceOpWithNewOp<spirv::CompositeConstructOp>(
155 op, spirvType, llvm::ArrayRef<Value>{resultRe, resultIm});
156 return success();
157 }
158};
159
160template <typename SqrtOp>
161struct AbsOpPattern final : OpConversionPattern<complex::AbsOp> {
162 using OpConversionPattern<complex::AbsOp>::OpConversionPattern;
163
164 LogicalResult
165 matchAndRewrite(complex::AbsOp op, OpAdaptor adaptor,
166 ConversionPatternRewriter &rewriter) const override {
167 Type spirvType =
168 this->getTypeConverter()->convertType(op.getResult().getType());
169 if (!spirvType)
170 return rewriter.notifyMatchFailure(op, "unable to convert result type");
171
172 Location loc = op.getLoc();
173 Value complexVal = adaptor.getComplex();
174
175 Value re =
176 spirv::CompositeExtractOp::create(rewriter, loc, complexVal, {0});
177 Value im =
178 spirv::CompositeExtractOp::create(rewriter, loc, complexVal, {1});
179
180 Value reSq = spirv::FMulOp::create(rewriter, loc, re, re);
181 Value imSq = spirv::FMulOp::create(rewriter, loc, im, im);
182 Value sum = spirv::FAddOp::create(rewriter, loc, reSq, imSq);
183
184 rewriter.replaceOpWithNewOp<SqrtOp>(op, sum);
185 return success();
186 }
187};
188
189template <typename ComplexOp, bool NegateReal>
190struct NegationOpPattern final : OpConversionPattern<ComplexOp> {
191 using OpConversionPattern<ComplexOp>::OpConversionPattern;
192 using OpAdaptor = typename ComplexOp::Adaptor;
193
194 LogicalResult
195 matchAndRewrite(ComplexOp op, OpAdaptor adaptor,
196 ConversionPatternRewriter &rewriter) const override {
197 Type spirvType =
198 this->getTypeConverter()->convertType(op.getResult().getType());
199 if (!spirvType)
200 return rewriter.notifyMatchFailure(op, "unable to convert result type");
201
202 Location loc = op.getLoc();
203 Value complexVal = adaptor.getComplex();
204
205 Value re =
206 spirv::CompositeExtractOp::create(rewriter, loc, complexVal, {0});
207 Value im =
208 spirv::CompositeExtractOp::create(rewriter, loc, complexVal, {1});
209
210 Value resultRe =
211 NegateReal ? spirv::FNegateOp::create(rewriter, loc, re) : re;
212 Value resultIm = spirv::FNegateOp::create(rewriter, loc, im);
213
214 rewriter.replaceOpWithNewOp<spirv::CompositeConstructOp>(
215 op, spirvType, llvm::ArrayRef<Value>{resultRe, resultIm});
216 return success();
217 }
218};
219
220struct DivOpPattern final : OpConversionPattern<complex::DivOp> {
221 using Base::Base;
222
223 LogicalResult
224 matchAndRewrite(complex::DivOp op, OpAdaptor adaptor,
225 ConversionPatternRewriter &rewriter) const override {
226 Type spirvType = getTypeConverter()->convertType(op.getResult().getType());
227 if (!spirvType)
228 return rewriter.notifyMatchFailure(op, "unable to convert result type");
229
230 Location loc = op.getLoc();
231 Value lhs = adaptor.getLhs();
232 Value rhs = adaptor.getRhs();
233
234 Value a = spirv::CompositeExtractOp::create(rewriter, loc, lhs, {0});
235 Value b = spirv::CompositeExtractOp::create(rewriter, loc, lhs, {1});
236 Value c = spirv::CompositeExtractOp::create(rewriter, loc, rhs, {0});
237 Value d = spirv::CompositeExtractOp::create(rewriter, loc, rhs, {1});
238
239 Value ac = spirv::FMulOp::create(rewriter, loc, a, c);
240 Value bd = spirv::FMulOp::create(rewriter, loc, b, d);
241 Value bc = spirv::FMulOp::create(rewriter, loc, b, c);
242 Value ad = spirv::FMulOp::create(rewriter, loc, a, d);
243 Value cc = spirv::FMulOp::create(rewriter, loc, c, c);
244 Value dd = spirv::FMulOp::create(rewriter, loc, d, d);
245 Value denom = spirv::FAddOp::create(rewriter, loc, cc, dd);
246 Value numRe = spirv::FAddOp::create(rewriter, loc, ac, bd);
247 Value numIm = spirv::FSubOp::create(rewriter, loc, bc, ad);
248 Value resultRe = spirv::FDivOp::create(rewriter, loc, numRe, denom);
249 Value resultIm = spirv::FDivOp::create(rewriter, loc, numIm, denom);
250
251 rewriter.replaceOpWithNewOp<spirv::CompositeConstructOp>(
252 op, spirvType, llvm::ArrayRef<Value>{resultRe, resultIm});
253 return success();
254 }
255};
256
257} // namespace
258
259//===----------------------------------------------------------------------===//
260// Pattern population
261//===----------------------------------------------------------------------===//
262
263void mlir::populateComplexToSPIRVPatterns(
264 const SPIRVTypeConverter &typeConverter, RewritePatternSet &patterns) {
265 MLIRContext *context = patterns.getContext();
266
267 patterns.add<ConstantOpPattern, CreateOpPattern, ReOpPattern, ImOpPattern,
268 ElementwiseBinaryOpPattern<complex::AddOp, spirv::FAddOp>,
269 ElementwiseBinaryOpPattern<complex::SubOp, spirv::FSubOp>,
270 MulOpPattern, DivOpPattern,
271 NegationOpPattern<complex::NegOp, /*NegateReal=*/true>,
272 NegationOpPattern<complex::ConjOp, /*NegateReal=*/false>,
273 AbsOpPattern<spirv::GLSqrtOp>, AbsOpPattern<spirv::CLSqrtOp>>(
274 typeConverter, context);
275}
success
return success()
lhs
lhs
Definition AffineExpr.cpp:833
b
b
Return true if permutation is a valid permutation of the outer_dims_perm (case OuterOrInnerPerm::Oute...
Definition LinalgTransformOps.cpp:2136
mlir::DenseElementsAttr::get
static DenseElementsAttr get(ShapedType type, ArrayRef< Attribute > values)
Constructs a dense elements attribute from an array of element values.
Definition BuiltinAttributes.cpp:870
mlir::Location
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
Definition Location.h:76
mlir::MLIRContext
MLIRContext is the top-level object for a collection of MLIR operations.
Definition MLIRContext.h:63
mlir::RewritePatternSet::getContext
MLIRContext * getContext() const
Definition PatternMatch.h:837
mlir::RewritePatternSet::add
RewritePatternSet & add(ConstructorArg &&arg, ConstructorArgs &&...args)
Add an instance of each of the pattern types 'Ts' to the pattern list with the given arguments.
Definition PatternMatch.h:861
mlir::SPIRVTypeConverter
Type conversion from builtin types to SPIR-V types for shader interface.
Definition SPIRVConversion.h:74
mlir::Type
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
Definition Types.h:74
mlir::Value
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Definition Value.h:96
mlir
Include the generated interface declarations.
Definition ABIRewriteContext.h:29
mlir::populateComplexToSPIRVPatterns
void populateComplexToSPIRVPatterns(const SPIRVTypeConverter &typeConverter, RewritePatternSet &patterns)
Appends to a pattern list additional patterns for translating Complex ops to SPIR-V ops.
Definition ComplexToSPIRV.cpp:263
Generated on for MLIR by doxygen 1.14.0