This is an archive of the discontinued LLVM Phabricator instance.

Differential D137523

[mlir][complex] Canonicalize complex.sub zero
ClosedPublic

Authored by Lewuathe on Nov 6 2022, 7:36 PM.

Details

Reviewers
pifon2a
nicolasvasilache
Commits
rGc9741baf5313: [mlir][complex] Canonicalize complex.sub zero
Summary

Subtracting zero constant can be fold in no complex.sub operation.

Diff Detail

Event Timeline

Lewuathe created this revision.Nov 6 2022, 7:36 PM
Herald added a project: Restricted Project. · View Herald TranscriptNov 6 2022, 7:36 PM
Herald added subscribers: Moerafaat, zero9178, bzcheeseman and 20 others. · View Herald Transcript
Lewuathe requested review of this revision.Nov 6 2022, 7:36 PM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptNov 6 2022, 7:36 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
Harbormaster completed remote builds in B196392: Diff 473547.Nov 6 2022, 7:56 PM
pifon2a accepted this revision.Nov 9 2022, 1:55 AM
This revision is now accepted and ready to land.Nov 9 2022, 1:55 AM
Closed by commit rGc9741baf5313: [mlir][complex] Canonicalize complex.sub zero (authored by Lewuathe, committed by pifon2a). · Explain WhyNov 9 2022, 3:17 AM
This revision was automatically updated to reflect the committed changes.
pifon2a added a commit: rGc9741baf5313: [mlir][complex] Canonicalize complex.sub zero.

Revision Contents

PathSize
mlir/
lib/
Dialect/
Complex/
IR/
9 lines
test/
Dialect/
Complex/
10 lines

Diff 474214

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

Show First 20 Lines • Show All 144 Lines • ▼ Show 20 Lines
OpFoldResult SubOp::fold(ArrayRef<Attribute> operands) { OpFoldResult SubOp::fold(ArrayRef<Attribute> operands) {
assert(operands.size() == 2 && "binary op takes 2 operands"); assert(operands.size() == 2 && "binary op takes 2 operands");
// complex.sub(complex.add(a, b), b) -> a // complex.sub(complex.add(a, b), b) -> a
if (auto add = getLhs().getDefiningOp<AddOp>()) if (auto add = getLhs().getDefiningOp<AddOp>())
if (getRhs() == add.getRhs()) if (getRhs() == add.getRhs())
return add.getLhs(); return add.getLhs();
// complex.sub(a, complex.constant<0.0, 0.0>) -> a
if (auto constantOp = getRhs().getDefiningOp<ConstantOp>()) {
auto arrayAttr = constantOp.getValue();
if (arrayAttr[0].cast<FloatAttr>().getValue().isZero() &&
arrayAttr[1].cast<FloatAttr>().getValue().isZero()) {
return getLhs();
}
}
return {}; return {};
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// NegOp // NegOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
OpFoldResult NegOp::fold(ArrayRef<Attribute> operands) { OpFoldResult NegOp::fold(ArrayRef<Attribute> operands) {
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

mlir/test/Dialect/Complex/canonicalize.mlir

Show First 20 Lines • Show All 138 Lines • ▼ Show 20 Lines
func.func @complex_sub_add_lhs() -> complex<f32> { func.func @complex_sub_add_lhs() -> complex<f32> {
%complex1 = complex.constant [1.0 : f32, 0.0 : f32] : complex<f32> %complex1 = complex.constant [1.0 : f32, 0.0 : f32] : complex<f32>
%complex2 = complex.constant [0.0 : f32, 2.0 : f32] : complex<f32> %complex2 = complex.constant [0.0 : f32, 2.0 : f32] : complex<f32>
// CHECK: %[[CPLX:.*]] = complex.constant [1.000000e+00 : f32, 0.000000e+00 : f32] : complex<f32> // CHECK: %[[CPLX:.*]] = complex.constant [1.000000e+00 : f32, 0.000000e+00 : f32] : complex<f32>
// CHECK-NEXT: return %[[CPLX:.*]] : complex<f32> // CHECK-NEXT: return %[[CPLX:.*]] : complex<f32>
%add = complex.add %complex1, %complex2 : complex<f32> %add = complex.add %complex1, %complex2 : complex<f32>
%sub = complex.sub %add, %complex2 : complex<f32> %sub = complex.sub %add, %complex2 : complex<f32>
return %sub : complex<f32> return %sub : complex<f32>
}
// CHECK-LABEL: func @complex_sub_zero
func.func @complex_sub_zero() -> complex<f32> {
%complex1 = complex.constant [1.0 : f32, 0.0 : f32] : complex<f32>
%complex2 = complex.constant [0.0 : f32, 0.0 : f32] : complex<f32>
// CHECK: %[[CPLX:.*]] = complex.constant [1.000000e+00 : f32, 0.000000e+00 : f32] : complex<f32>
// CHECK-NEXT: return %[[CPLX:.*]] : complex<f32>
%sub = complex.sub %complex1, %complex2 : complex<f32>
return %sub : complex<f32>
} }
No newline at end of file No newline at end of file