This is an archive of the discontinued LLVM Phabricator instance.

Differential D103141

[mlir] Fold complex.re(complex.create) and complex.im(complex.create)
ClosedPublic

Authored by akuegel on May 26 2021, 12:46 AM.

Details

Reviewers
pifon2a
ftynse
Commits
rGb99f892b025b: [mlir] Fold complex.re(complex.create) and complex.im(complex.create)
Summary

This extends the folding we already have. A test needs to be adjusted.

Diff Detail

Event Timeline

akuegel created this revision.May 26 2021, 12:46 AM
Herald added a reviewer: ftynse. · View Herald TranscriptMay 26 2021, 12:46 AM
Herald added subscribers: dcaballe, cota, teijeong and 16 others. · View Herald Transcript
akuegel requested review of this revision.May 26 2021, 12:46 AM
Herald added a project: Restricted Project. · View Herald TranscriptMay 26 2021, 12:46 AM
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
Harbormaster completed remote builds in B106220: Diff 347857.May 26 2021, 1:18 AM
pifon2a accepted this revision.May 26 2021, 1:51 AM
This revision is now accepted and ready to land.May 26 2021, 1:51 AM
rriddle added inline comments.May 26 2021, 1:52 AM
mlir/lib/Dialect/Complex/IR/ComplexOps.cpp
27
37
Closed by commit rGb99f892b025b: [mlir] Fold complex.re(complex.create) and complex.im(complex.create) (authored by akuegel). · Explain WhyMay 26 2021, 1:53 AM
This revision was automatically updated to reflect the committed changes.
akuegel added a commit: rGb99f892b025b: [mlir] Fold complex.re(complex.create) and complex.im(complex.create).
akuegel added inline comments.May 26 2021, 1:55 AM
mlir/lib/Dialect/Complex/IR/ComplexOps.cpp
37

Thanks for the suggestion :)
Will fix in a followup commit, unfortunately I didn't see your comment in time.

akuegel added inline comments.May 26 2021, 2:01 AM
mlir/lib/Dialect/Complex/IR/ComplexOps.cpp
37

Done in https://github.com/llvm/llvm-project/commit/cb65419b1ac05c3020dd05b64db183712235d2ff

Revision Contents

PathSize
mlir/
lib/
Dialect/
Complex/
IR/
4 lines
test/
Conversion/
ComplexToLLVM/
27 lines
Dialect/
Complex/
22 lines

Diff 347863

mlir/lib/Dialect/Complex/IR/ComplexOps.cpp

Show All 18 Lines
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "mlir/Dialect/Complex/IR/ComplexOps.cpp.inc" #include "mlir/Dialect/Complex/IR/ComplexOps.cpp.inc"
OpFoldResult ReOp::fold(ArrayRef<Attribute> operands) { OpFoldResult ReOp::fold(ArrayRef<Attribute> operands) {
assert(operands.size() == 1 && "unary op takes 1 operand"); assert(operands.size() == 1 && "unary op takes 1 operand");
ArrayAttr arrayAttr = operands[0].dyn_cast_or_null<ArrayAttr>(); ArrayAttr arrayAttr = operands[0].dyn_cast_or_null<ArrayAttr>();
if (arrayAttr && arrayAttr.size() == 2) if (arrayAttr && arrayAttr.size() == 2)
return arrayAttr[0]; return arrayAttr[0];
if (auto createOp = dyn_cast_or_null<CreateOp>(getOperand().getDefiningOp()))
rriddleUnsubmitted
Not Done
ReplyInline Actions
return arrayAttr[0];
- if (auto createOp = dyn_cast_or_null<CreateOp>(getOperand().getDefiningOp()))
+ if (auto createOp = getOperand().getDefiningOp<CreateOp>())
return createOp.getOperand(0);
rriddle:
return createOp.getOperand(0);
return {}; return {};
} }
OpFoldResult ImOp::fold(ArrayRef<Attribute> operands) { OpFoldResult ImOp::fold(ArrayRef<Attribute> operands) {
assert(operands.size() == 1 && "unary op takes 1 operand"); assert(operands.size() == 1 && "unary op takes 1 operand");
ArrayAttr arrayAttr = operands[0].dyn_cast_or_null<ArrayAttr>(); ArrayAttr arrayAttr = operands[0].dyn_cast_or_null<ArrayAttr>();
if (arrayAttr && arrayAttr.size() == 2) if (arrayAttr && arrayAttr.size() == 2)
return arrayAttr[1]; return arrayAttr[1];
if (auto createOp = dyn_cast_or_null<CreateOp>(getOperand().getDefiningOp()))
rriddleUnsubmitted
Not Done
ReplyInline Actions
return arrayAttr[1];
- if (auto createOp = dyn_cast_or_null<CreateOp>(getOperand().getDefiningOp()))
+ if (auto createOp = getOperand().getDefiningOp<CreateOp>())
return createOp.getOperand(1);
rriddle:
akuegelAuthorUnsubmitted
Done
ReplyInline Actions

Thanks for the suggestion :)
Will fix in a followup commit, unfortunately I didn't see your comment in time.

akuegel: Thanks for the suggestion :) Will fix in a followup commit, unfortunately I didn't see your…
akuegelAuthorUnsubmitted
Done
ReplyInline Actions

Done in https://github.com/llvm/llvm-project/commit/cb65419b1ac05c3020dd05b64db183712235d2ff

akuegel: Done in https://github.com/llvm/llvm-project/commit/cb65419b1ac05c3020dd05b64db183712235d2ff
return createOp.getOperand(1);
return {}; return {};
} }

mlir/test/Conversion/ComplexToLLVM/convert-to-llvm.mlir

// RUN: mlir-opt %s -convert-complex-to-llvm | FileCheck %s // RUN: mlir-opt %s -convert-complex-to-llvm | FileCheck %s
// CHECK-LABEL: func @complex_numbers // CHECK-LABEL: func @complex_create
// CHECK-NEXT: %[[REAL0:.*]] = constant 1.200000e+00 : f32 // CHECK-SAME: (%[[REAL0:.*]]: f32, %[[IMAG0:.*]]: f32)
// CHECK-NEXT: %[[IMAG0:.*]] = constant 3.400000e+00 : f32
// CHECK-NEXT: %[[CPLX0:.*]] = llvm.mlir.undef : !llvm.struct<(f32, f32)> // CHECK-NEXT: %[[CPLX0:.*]] = llvm.mlir.undef : !llvm.struct<(f32, f32)>
// CHECK-NEXT: %[[CPLX1:.*]] = llvm.insertvalue %[[REAL0]], %[[CPLX0]][0] : !llvm.struct<(f32, f32)> // CHECK-NEXT: %[[CPLX1:.*]] = llvm.insertvalue %[[REAL0]], %[[CPLX0]][0] : !llvm.struct<(f32, f32)>
// CHECK-NEXT: %[[CPLX2:.*]] = llvm.insertvalue %[[IMAG0]], %[[CPLX1]][1] : !llvm.struct<(f32, f32)> // CHECK-NEXT: %[[CPLX2:.*]] = llvm.insertvalue %[[IMAG0]], %[[CPLX1]][1] : !llvm.struct<(f32, f32)>
// CHECK-NEXT: %[[REAL1:.*]] = llvm.extractvalue %[[CPLX2:.*]][0] : !llvm.struct<(f32, f32)> func @complex_create(%real: f32, %imag: f32) -> complex<f32> {
// CHECK-NEXT: %[[IMAG1:.*]] = llvm.extractvalue %[[CPLX2:.*]][1] : !llvm.struct<(f32, f32)> %cplx2 = complex.create %real, %imag : complex<f32>
func @complex_numbers() { return %cplx2 : complex<f32>
%real0 = constant 1.2 : f32 }
%imag0 = constant 3.4 : f32
%cplx2 = complex.create %real0, %imag0 : complex<f32> // CHECK-LABEL: func @complex_extract
%real1 = complex.re%cplx2 : complex<f32> // CHECK-SAME: (%[[CPLX:.*]]: complex<f32>)
%imag1 = complex.im %cplx2 : complex<f32> // CHECK-NEXT: %[[CAST0:.*]] = llvm.mlir.cast %[[CPLX]] : complex<f32> to !llvm.struct<(f32, f32)>
// CHECK-NEXT: %[[REAL:.*]] = llvm.extractvalue %[[CAST0]][0] : !llvm.struct<(f32, f32)>
// CHECK-NEXT: %[[CAST1:.*]] = llvm.mlir.cast %[[CPLX]] : complex<f32> to !llvm.struct<(f32, f32)>
// CHECK-NEXT: %[[IMAG:.*]] = llvm.extractvalue %[[CAST1]][1] : !llvm.struct<(f32, f32)>
func @complex_extract(%cplx: complex<f32>) {
%real1 = complex.re %cplx : complex<f32>
%imag1 = complex.im %cplx : complex<f32>
return return
} }
// CHECK-LABEL: func @complex_addition // CHECK-LABEL: func @complex_addition
// CHECK-DAG: %[[A_REAL:.*]] = llvm.extractvalue %[[A:.*]][0] : !llvm.struct<(f64, f64)> // CHECK-DAG: %[[A_REAL:.*]] = llvm.extractvalue %[[A:.*]][0] : !llvm.struct<(f64, f64)>
// CHECK-DAG: %[[B_REAL:.*]] = llvm.extractvalue %[[B:.*]][0] : !llvm.struct<(f64, f64)> // CHECK-DAG: %[[B_REAL:.*]] = llvm.extractvalue %[[B:.*]][0] : !llvm.struct<(f64, f64)>
// CHECK-DAG: %[[A_IMAG:.*]] = llvm.extractvalue %[[A]][1] : !llvm.struct<(f64, f64)> // CHECK-DAG: %[[A_IMAG:.*]] = llvm.extractvalue %[[A]][1] : !llvm.struct<(f64, f64)>
// CHECK-DAG: %[[B_IMAG:.*]] = llvm.extractvalue %[[B]][1] : !llvm.struct<(f64, f64)> // CHECK-DAG: %[[B_IMAG:.*]] = llvm.extractvalue %[[B]][1] : !llvm.struct<(f64, f64)>
▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

mlir/test/Dialect/Complex/canonicalize.mlir

// RUN: mlir-opt %s -canonicalize | FileCheck %s // RUN: mlir-opt %s -canonicalize | FileCheck %s
// CHECK-LABEL: func @real_of_const( // CHECK-LABEL: func @real_of_const(
func @real_of_const() -> f32 { func @real_of_const() -> f32 {
// CHECK: %[[CST:.*]] = constant 1.000000e+00 : f32 // CHECK: %[[CST:.*]] = constant 1.000000e+00 : f32
// CHECK-NEXT: return %[[CST]] : f32 // CHECK-NEXT: return %[[CST]] : f32
%complex = constant [1.0 : f32, 0.0 : f32] : complex<f32> %complex = constant [1.0 : f32, 0.0 : f32] : complex<f32>
%1 = complex.re %complex : complex<f32> %1 = complex.re %complex : complex<f32>
return %1 : f32 return %1 : f32
} }
// CHECK-LABEL: func @real_of_create_op(
func @real_of_create_op() -> f32 {
// CHECK: %[[CST:.*]] = constant 1.000000e+00 : f32
// CHECK-NEXT: return %[[CST]] : f32
%real = constant 1.0 : f32
%imag = constant 0.0 : f32
%complex = complex.create %real, %imag : complex<f32>
%1 = complex.re %complex : complex<f32>
return %1 : f32
}
// CHECK-LABEL: func @imag_of_const( // CHECK-LABEL: func @imag_of_const(
func @imag_of_const() -> f32 { func @imag_of_const() -> f32 {
// CHECK: %[[CST:.*]] = constant 0.000000e+00 : f32 // CHECK: %[[CST:.*]] = constant 0.000000e+00 : f32
// CHECK-NEXT: return %[[CST]] : f32 // CHECK-NEXT: return %[[CST]] : f32
%complex = constant [1.0 : f32, 0.0 : f32] : complex<f32> %complex = constant [1.0 : f32, 0.0 : f32] : complex<f32>
%1 = complex.im %complex : complex<f32> %1 = complex.im %complex : complex<f32>
return %1 : f32 return %1 : f32
} }
// CHECK-LABEL: func @imag_of_create_op(
func @imag_of_create_op() -> f32 {
// CHECK: %[[CST:.*]] = constant 0.000000e+00 : f32
// CHECK-NEXT: return %[[CST]] : f32
%real = constant 1.0 : f32
%imag = constant 0.0 : f32
%complex = complex.create %real, %imag : complex<f32>
%1 = complex.im %complex : complex<f32>
return %1 : f32
}