1//===- ComplexToLLVM.cpp - conversion from Complex to LLVM dialect --------===//
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#include "mlir/Conversion/ComplexToLLVM/ComplexToLLVM.h"
10
11#include "mlir/Conversion/ArithAttrToLLVM/AttrToLLVMConverter.h"
12#include "mlir/Conversion/ComplexCommon/DivisionConverter.h"
13#include "mlir/Conversion/ConvertToLLVM/ToLLVMInterface.h"
14#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
15#include "mlir/Conversion/LLVMCommon/Pattern.h"
16#include "mlir/Dialect/Arith/IR/Arith.h"
17#include "mlir/Dialect/Complex/IR/Complex.h"
18#include "mlir/Dialect/LLVMIR/LLVMArithOps.h"
19#include "mlir/Dialect/LLVMIR/LLVMConstantOps.h"
20#include "mlir/Dialect/LLVMIR/LLVMFloatIntrinsicOps.h"
21
22namespace mlir {
23#define GEN_PASS_DEF_CONVERTCOMPLEXTOLLVMPASS
24#include "mlir/Conversion/Passes.h.inc"
25} // namespace mlir
26
27using namespace mlir;
28using namespace mlir::LLVM;
29using namespace mlir::arith;
30
31//===----------------------------------------------------------------------===//
32// ComplexStructBuilder implementation.
33//===----------------------------------------------------------------------===//
34
35static constexpr unsigned kRealPosInComplexNumberStruct = 0;
36static constexpr unsigned kImaginaryPosInComplexNumberStruct = 1;
37
38ComplexStructBuilder ComplexStructBuilder::poison(OpBuilder &builder,
39 Location loc, Type type) {
40 Value val = LLVM::PoisonOp::create(builder, location: loc, res: type);
41 return ComplexStructBuilder(val);
42}
43
44void ComplexStructBuilder::setReal(OpBuilder &builder, Location loc,
45 Value real) {
46 setPtr(builder, loc, pos: kRealPosInComplexNumberStruct, ptr: real);
47}
48
49Value ComplexStructBuilder::real(OpBuilder &builder, Location loc) {
50 return extractPtr(builder, loc, pos: kRealPosInComplexNumberStruct);
51}
52
53void ComplexStructBuilder::setImaginary(OpBuilder &builder, Location loc,
54 Value imaginary) {
55 setPtr(builder, loc, pos: kImaginaryPosInComplexNumberStruct, ptr: imaginary);
56}
57
58Value ComplexStructBuilder::imaginary(OpBuilder &builder, Location loc) {
59 return extractPtr(builder, loc, pos: kImaginaryPosInComplexNumberStruct);
60}
61
62//===----------------------------------------------------------------------===//
63// Conversion patterns.
64//===----------------------------------------------------------------------===//
65
66namespace {
67
68struct AbsOpConversion : public ConvertOpToLLVMPattern<complex::AbsOp> {
69 using ConvertOpToLLVMPattern<complex::AbsOp>::ConvertOpToLLVMPattern;
70
71 LogicalResult
72 matchAndRewrite(complex::AbsOp op, OpAdaptor adaptor,
73 ConversionPatternRewriter &rewriter) const override {
74 auto loc = op.getLoc();
75
76 ComplexStructBuilder complexStruct(adaptor.getComplex());
77 Value real = complexStruct.real(builder&: rewriter, loc: op.getLoc());
78 Value imag = complexStruct.imaginary(builder&: rewriter, loc: op.getLoc());
79
80 arith::FastMathFlagsAttr complexFMFAttr = op.getFastMathFlagsAttr();
81 LLVM::FastmathFlagsAttr fmf = LLVM::FastmathFlagsAttr::get(
82 context: op.getContext(),
83 value: convertArithFastMathFlagsToLLVM(arithFMF: complexFMFAttr.getValue()));
84 Value sqNorm = LLVM::FAddOp::create(
85 builder&: rewriter, location: loc, lhs: LLVM::FMulOp::create(builder&: rewriter, location: loc, lhs: real, rhs: real, fastmathFlags: fmf),
86 rhs: LLVM::FMulOp::create(builder&: rewriter, location: loc, lhs: imag, rhs: imag, fastmathFlags: fmf), fastmathFlags: fmf);
87
88 rewriter.replaceOpWithNewOp<LLVM::SqrtOp>(op, args&: sqNorm, args&: fmf);
89 return success();
90 }
91};
92
93struct ConstantOpLowering : public ConvertOpToLLVMPattern<complex::ConstantOp> {
94 using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern;
95
96 LogicalResult
97 matchAndRewrite(complex::ConstantOp op, OpAdaptor adaptor,
98 ConversionPatternRewriter &rewriter) const override {
99 return LLVM::detail::oneToOneRewrite(
100 op, targetOp: LLVM::ConstantOp::getOperationName(), operands: adaptor.getOperands(),
101 targetAttrs: op->getDiscardableAttrDictionary().getValue(),
102 propertiesAttr: op->getPropertiesAsAttribute(), typeConverter: *getTypeConverter(), rewriter);
103 }
104};
105
106struct CreateOpConversion : public ConvertOpToLLVMPattern<complex::CreateOp> {
107 using ConvertOpToLLVMPattern<complex::CreateOp>::ConvertOpToLLVMPattern;
108
109 LogicalResult
110 matchAndRewrite(complex::CreateOp complexOp, OpAdaptor adaptor,
111 ConversionPatternRewriter &rewriter) const override {
112 // Pack real and imaginary part in a complex number struct.
113 auto loc = complexOp.getLoc();
114 auto structType = typeConverter->convertType(t: complexOp.getType());
115 auto complexStruct =
116 ComplexStructBuilder::poison(builder&: rewriter, loc, type: structType);
117 complexStruct.setReal(builder&: rewriter, loc, real: adaptor.getReal());
118 complexStruct.setImaginary(builder&: rewriter, loc, imaginary: adaptor.getImaginary());
119
120 rewriter.replaceOp(op: complexOp, newValues: {complexStruct});
121 return success();
122 }
123};
124
125struct ReOpConversion : public ConvertOpToLLVMPattern<complex::ReOp> {
126 using ConvertOpToLLVMPattern<complex::ReOp>::ConvertOpToLLVMPattern;
127
128 LogicalResult
129 matchAndRewrite(complex::ReOp op, OpAdaptor adaptor,
130 ConversionPatternRewriter &rewriter) const override {
131 // Extract real part from the complex number struct.
132 ComplexStructBuilder complexStruct(adaptor.getComplex());
133 Value real = complexStruct.real(builder&: rewriter, loc: op.getLoc());
134 rewriter.replaceOp(op, newValues: real);
135
136 return success();
137 }
138};
139
140struct ImOpConversion : public ConvertOpToLLVMPattern<complex::ImOp> {
141 using ConvertOpToLLVMPattern<complex::ImOp>::ConvertOpToLLVMPattern;
142
143 LogicalResult
144 matchAndRewrite(complex::ImOp op, OpAdaptor adaptor,
145 ConversionPatternRewriter &rewriter) const override {
146 // Extract imaginary part from the complex number struct.
147 ComplexStructBuilder complexStruct(adaptor.getComplex());
148 Value imaginary = complexStruct.imaginary(builder&: rewriter, loc: op.getLoc());
149 rewriter.replaceOp(op, newValues: imaginary);
150
151 return success();
152 }
153};
154
155struct BinaryComplexOperands {
156 mlir::Complex<Value> lhs;
157 mlir::Complex<Value> rhs;
158};
159
160template <typename OpTy>
161BinaryComplexOperands
162unpackBinaryComplexOperands(OpTy op, typename OpTy::Adaptor adaptor,
163 ConversionPatternRewriter &rewriter) {
164 auto loc = op.getLoc();
165
166 // Extract real and imaginary values from operands.
167 BinaryComplexOperands unpacked;
168 ComplexStructBuilder lhs(adaptor.getLhs());
169 unpacked.lhs.real(lhs.real(builder&: rewriter, loc));
170 unpacked.lhs.imag(lhs.imaginary(builder&: rewriter, loc));
171 ComplexStructBuilder rhs(adaptor.getRhs());
172 unpacked.rhs.real(rhs.real(builder&: rewriter, loc));
173 unpacked.rhs.imag(rhs.imaginary(builder&: rewriter, loc));
174
175 return unpacked;
176}
177
178struct AddOpConversion : public ConvertOpToLLVMPattern<complex::AddOp> {
179 using ConvertOpToLLVMPattern<complex::AddOp>::ConvertOpToLLVMPattern;
180
181 LogicalResult
182 matchAndRewrite(complex::AddOp op, OpAdaptor adaptor,
183 ConversionPatternRewriter &rewriter) const override {
184 auto loc = op.getLoc();
185 BinaryComplexOperands arg =
186 unpackBinaryComplexOperands<complex::AddOp>(op, adaptor, rewriter);
187
188 // Initialize complex number struct for result.
189 auto structType = typeConverter->convertType(t: op.getType());
190 auto result = ComplexStructBuilder::poison(builder&: rewriter, loc, type: structType);
191
192 // Emit IR to add complex numbers.
193 arith::FastMathFlagsAttr complexFMFAttr = op.getFastMathFlagsAttr();
194 LLVM::FastmathFlagsAttr fmf = LLVM::FastmathFlagsAttr::get(
195 context: op.getContext(),
196 value: convertArithFastMathFlagsToLLVM(arithFMF: complexFMFAttr.getValue()));
197 Value real = LLVM::FAddOp::create(builder&: rewriter, location: loc, lhs: arg.lhs.real(),
198 rhs: arg.rhs.real(), fastmathFlags: fmf);
199 Value imag = LLVM::FAddOp::create(builder&: rewriter, location: loc, lhs: arg.lhs.imag(),
200 rhs: arg.rhs.imag(), fastmathFlags: fmf);
201 result.setReal(builder&: rewriter, loc, real);
202 result.setImaginary(builder&: rewriter, loc, imaginary: imag);
203
204 rewriter.replaceOp(op, newValues: {result});
205 return success();
206 }
207};
208
209struct DivOpConversion : public ConvertOpToLLVMPattern<complex::DivOp> {
210 DivOpConversion(const LLVMTypeConverter &converter,
211 complex::ComplexRangeFlags target)
212 : ConvertOpToLLVMPattern<complex::DivOp>(converter),
213 complexRange(target) {}
214
215 using ConvertOpToLLVMPattern<complex::DivOp>::ConvertOpToLLVMPattern;
216
217 LogicalResult
218 matchAndRewrite(complex::DivOp op, OpAdaptor adaptor,
219 ConversionPatternRewriter &rewriter) const override {
220 auto loc = op.getLoc();
221 BinaryComplexOperands arg =
222 unpackBinaryComplexOperands<complex::DivOp>(op, adaptor, rewriter);
223
224 // Initialize complex number struct for result.
225 auto structType = typeConverter->convertType(t: op.getType());
226 auto result = ComplexStructBuilder::poison(builder&: rewriter, loc, type: structType);
227
228 // Emit IR to add complex numbers.
229 arith::FastMathFlagsAttr complexFMFAttr = op.getFastMathFlagsAttr();
230 LLVM::FastmathFlagsAttr fmf = LLVM::FastmathFlagsAttr::get(
231 context: op.getContext(),
232 value: convertArithFastMathFlagsToLLVM(arithFMF: complexFMFAttr.getValue()));
233 Value rhsRe = arg.rhs.real();
234 Value rhsIm = arg.rhs.imag();
235 Value lhsRe = arg.lhs.real();
236 Value lhsIm = arg.lhs.imag();
237
238 Value resultRe, resultIm;
239
240 if (complexRange == complex::ComplexRangeFlags::basic ||
241 complexRange == complex::ComplexRangeFlags::none) {
242 mlir::complex::convertDivToLLVMUsingAlgebraic(
243 rewriter, loc, lhsRe, lhsIm, rhsRe, rhsIm, fmf, resultRe: &resultRe, resultIm: &resultIm);
244 } else if (complexRange == complex::ComplexRangeFlags::improved) {
245 mlir::complex::convertDivToLLVMUsingRangeReduction(
246 rewriter, loc, lhsRe, lhsIm, rhsRe, rhsIm, fmf, resultRe: &resultRe, resultIm: &resultIm);
247 }
248
249 result.setReal(builder&: rewriter, loc, real: resultRe);
250 result.setImaginary(builder&: rewriter, loc, imaginary: resultIm);
251
252 rewriter.replaceOp(op, newValues: {result});
253 return success();
254 }
255
256private:
257 complex::ComplexRangeFlags complexRange;
258};
259
260struct MulOpConversion : public ConvertOpToLLVMPattern<complex::MulOp> {
261 using ConvertOpToLLVMPattern<complex::MulOp>::ConvertOpToLLVMPattern;
262
263 LogicalResult
264 matchAndRewrite(complex::MulOp op, OpAdaptor adaptor,
265 ConversionPatternRewriter &rewriter) const override {
266 auto loc = op.getLoc();
267 BinaryComplexOperands arg =
268 unpackBinaryComplexOperands<complex::MulOp>(op, adaptor, rewriter);
269
270 // Initialize complex number struct for result.
271 auto structType = typeConverter->convertType(t: op.getType());
272 auto result = ComplexStructBuilder::poison(builder&: rewriter, loc, type: structType);
273
274 // Emit IR to add complex numbers.
275 arith::FastMathFlagsAttr complexFMFAttr = op.getFastMathFlagsAttr();
276 LLVM::FastmathFlagsAttr fmf = LLVM::FastmathFlagsAttr::get(
277 context: op.getContext(),
278 value: convertArithFastMathFlagsToLLVM(arithFMF: complexFMFAttr.getValue()));
279 Value rhsRe = arg.rhs.real();
280 Value rhsIm = arg.rhs.imag();
281 Value lhsRe = arg.lhs.real();
282 Value lhsIm = arg.lhs.imag();
283
284 Value real;
285 Value imag;
286 if (arith::bitEnumContainsAll(bits: complexFMFAttr.getValue(),
287 bit: arith::FastMathFlags::contract)) {
288 Value lhsImagTimesRhsImag =
289 LLVM::FMulOp::create(builder&: rewriter, location: loc, lhs: lhsIm, rhs: rhsIm, fastmathFlags: fmf);
290 Value negLhsImagTimesRhsImag =
291 LLVM::FNegOp::create(builder&: rewriter, location: loc, operand: lhsImagTimesRhsImag, fastmathFlags: fmf);
292 real = LLVM::FMAOp::create(builder&: rewriter, location: loc, a: lhsRe, b: rhsRe,
293 c: negLhsImagTimesRhsImag, fastmathFlags: fmf);
294
295 Value lhsImagTimesRhsReal =
296 LLVM::FMulOp::create(builder&: rewriter, location: loc, lhs: lhsIm, rhs: rhsRe, fastmathFlags: fmf);
297 imag = LLVM::FMAOp::create(builder&: rewriter, location: loc, a: lhsRe, b: rhsIm,
298 c: lhsImagTimesRhsReal, fastmathFlags: fmf);
299 } else {
300 Value lhsRealTimesRhsReal =
301 LLVM::FMulOp::create(builder&: rewriter, location: loc, lhs: rhsRe, rhs: lhsRe, fastmathFlags: fmf);
302 Value lhsImagTimesRhsImag =
303 LLVM::FMulOp::create(builder&: rewriter, location: loc, lhs: rhsIm, rhs: lhsIm, fastmathFlags: fmf);
304 Value lhsImagTimesRhsReal =
305 LLVM::FMulOp::create(builder&: rewriter, location: loc, lhs: lhsIm, rhs: rhsRe, fastmathFlags: fmf);
306 Value lhsRealTimesRhsImag =
307 LLVM::FMulOp::create(builder&: rewriter, location: loc, lhs: lhsRe, rhs: rhsIm, fastmathFlags: fmf);
308
309 real = LLVM::FSubOp::create(builder&: rewriter, location: loc, lhs: lhsRealTimesRhsReal,
310 rhs: lhsImagTimesRhsImag, fastmathFlags: fmf);
311
312 imag = LLVM::FAddOp::create(builder&: rewriter, location: loc, lhs: lhsImagTimesRhsReal,
313 rhs: lhsRealTimesRhsImag, fastmathFlags: fmf);
314 }
315
316 result.setReal(builder&: rewriter, loc, real);
317 result.setImaginary(builder&: rewriter, loc, imaginary: imag);
318
319 rewriter.replaceOp(op, newValues: {result});
320 return success();
321 }
322};
323
324struct SubOpConversion : public ConvertOpToLLVMPattern<complex::SubOp> {
325 using ConvertOpToLLVMPattern<complex::SubOp>::ConvertOpToLLVMPattern;
326
327 LogicalResult
328 matchAndRewrite(complex::SubOp op, OpAdaptor adaptor,
329 ConversionPatternRewriter &rewriter) const override {
330 auto loc = op.getLoc();
331 BinaryComplexOperands arg =
332 unpackBinaryComplexOperands<complex::SubOp>(op, adaptor, rewriter);
333
334 // Initialize complex number struct for result.
335 auto structType = typeConverter->convertType(t: op.getType());
336 auto result = ComplexStructBuilder::poison(builder&: rewriter, loc, type: structType);
337
338 // Emit IR to substract complex numbers.
339 arith::FastMathFlagsAttr complexFMFAttr = op.getFastMathFlagsAttr();
340 LLVM::FastmathFlagsAttr fmf = LLVM::FastmathFlagsAttr::get(
341 context: op.getContext(),
342 value: convertArithFastMathFlagsToLLVM(arithFMF: complexFMFAttr.getValue()));
343 Value real = LLVM::FSubOp::create(builder&: rewriter, location: loc, lhs: arg.lhs.real(),
344 rhs: arg.rhs.real(), fastmathFlags: fmf);
345 Value imag = LLVM::FSubOp::create(builder&: rewriter, location: loc, lhs: arg.lhs.imag(),
346 rhs: arg.rhs.imag(), fastmathFlags: fmf);
347 result.setReal(builder&: rewriter, loc, real);
348 result.setImaginary(builder&: rewriter, loc, imaginary: imag);
349
350 rewriter.replaceOp(op, newValues: {result});
351 return success();
352 }
353};
354} // namespace
355
356void mlir::populateComplexToLLVMConversionPatterns(
357 const LLVMTypeConverter &converter, RewritePatternSet &patterns,
358 complex::ComplexRangeFlags complexRange) {
359 // clang-format off
360 patterns.add<
361 AbsOpConversion,
362 AddOpConversion,
363 ConstantOpLowering,
364 CreateOpConversion,
365 ImOpConversion,
366 MulOpConversion,
367 ReOpConversion,
368 SubOpConversion
369 >(arg: converter);
370
371 patterns.add<DivOpConversion>(arg: converter, args&: complexRange);
372 // clang-format on
373}
374
375namespace {
376struct ConvertComplexToLLVMPass
377 : public impl::ConvertComplexToLLVMPassBase<ConvertComplexToLLVMPass> {
378 using Base::Base;
379
380 void runOnOperation() override;
381};
382} // namespace
383
384void ConvertComplexToLLVMPass::runOnOperation() {
385 // Convert to the LLVM IR dialect using the converter defined above.
386 RewritePatternSet patterns(&getContext());
387 LLVMTypeConverter converter(&getContext());
388 populateComplexToLLVMConversionPatterns(converter, patterns, complexRange);
389
390 LLVMConversionTarget target(getContext());
391 target.addIllegalDialect<complex::ComplexDialect>();
392 if (failed(
393 Result: applyPartialConversion(op: getOperation(), target, patterns: std::move(patterns))))
394 signalPassFailure();
395}
396
397//===----------------------------------------------------------------------===//
398// ConvertToLLVMPatternInterface implementation
399//===----------------------------------------------------------------------===//
400
401namespace {
402/// Implement the interface to convert MemRef to LLVM.
403struct ComplexToLLVMDialectInterface : public ConvertToLLVMPatternInterface {
404 ComplexToLLVMDialectInterface(Dialect *dialect)
405 : ConvertToLLVMPatternInterface(dialect) {}
406
407 void loadDependentDialects(MLIRContext *context) const final {
408 context->loadDialect<LLVM::LLVMDialect>();
409 }
410
411 /// Hook for derived dialect interface to provide conversion patterns
412 /// and mark dialect legal for the conversion target.
413 void populateConvertToLLVMConversionPatterns(
414 ConversionTarget &target, LLVMTypeConverter &typeConverter,
415 RewritePatternSet &patterns) const final {
416 populateComplexToLLVMConversionPatterns(converter: typeConverter, patterns);
417 }
418};
419} // namespace
420
421void mlir::registerConvertComplexToLLVMInterface(DialectRegistry &registry) {
422 registry.addExtension(
423 extensionFn: +[](MLIRContext *ctx, complex::ComplexDialect *dialect) {
424 dialect->addInterfaces<ComplexToLLVMDialectInterface>();
425 });
426}
427