From c2693db264900005ceb13f917dc1fab0cbf8d459 Mon Sep 17 00:00:00 2001 From: Simon Vandel Sillesen Date: Sat, 29 Aug 2020 14:16:39 +0200 Subject: [PATCH 1/2] Add peephold optimization that simplifies Ne(_1, false) and Ne(false, _1) into _1 This was observed emitted from the MatchBranchSimplification pass. --- compiler/rustc_middle/src/mir/mod.rs | 9 +++ .../rustc_mir/src/transform/instcombine.rs | 37 +++++++++- compiler/rustc_mir/src/transform/mod.rs | 3 +- .../not_equal_false.opt.InstCombine.diff | 72 +++++++++++++++++++ src/test/mir-opt/not_equal_false.rs | 9 +++ 5 files changed, 128 insertions(+), 2 deletions(-) create mode 100644 src/test/mir-opt/not_equal_false.opt.InstCombine.diff create mode 100644 src/test/mir-opt/not_equal_false.rs diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs index 1181ba6bbf946..96e2a0ba618a3 100644 --- a/compiler/rustc_middle/src/mir/mod.rs +++ b/compiler/rustc_middle/src/mir/mod.rs @@ -1954,6 +1954,15 @@ impl<'tcx> Operand<'tcx> { Operand::Constant(_) => None, } } + + /// Returns the `Constant` that is the target of this `Operand`, or `None` if this `Operand` is a + /// place. + pub fn constant(&self) -> Option<&Constant<'tcx>> { + match self { + Operand::Constant(x) => Some(&**x), + Operand::Copy(_) | Operand::Move(_) => None, + } + } } /////////////////////////////////////////////////////////////////////////// diff --git a/compiler/rustc_mir/src/transform/instcombine.rs b/compiler/rustc_mir/src/transform/instcombine.rs index c6474ba2d7328..18cf2a2ff218b 100644 --- a/compiler/rustc_mir/src/transform/instcombine.rs +++ b/compiler/rustc_mir/src/transform/instcombine.rs @@ -6,7 +6,7 @@ use rustc_hir::Mutability; use rustc_index::vec::Idx; use rustc_middle::mir::visit::{MutVisitor, Visitor}; use rustc_middle::mir::{ - Body, Constant, Local, Location, Operand, Place, PlaceRef, ProjectionElem, Rvalue, + BinOp, Body, Constant, Local, Location, Operand, Place, PlaceRef, ProjectionElem, Rvalue, }; use rustc_middle::ty::{self, TyCtxt}; use std::mem; @@ -66,6 +66,11 @@ impl<'tcx> MutVisitor<'tcx> for InstCombineVisitor<'tcx> { *rvalue = Rvalue::Use(Operand::Constant(box constant)); } + if let Some(operand) = self.optimizations.unneeded_not_equal.remove(&location) { + debug!("replacing {:?} with {:?}", rvalue, operand); + *rvalue = Rvalue::Use(operand); + } + self.super_rvalue(rvalue, location) } } @@ -81,6 +86,23 @@ impl OptimizationFinder<'b, 'tcx> { fn new(body: &'b Body<'tcx>, tcx: TyCtxt<'tcx>) -> OptimizationFinder<'b, 'tcx> { OptimizationFinder { body, tcx, optimizations: OptimizationList::default() } } + + fn find_operand_in_ne_false_pattern( + &self, + l: &Operand<'tcx>, + r: &'a Operand<'tcx>, + ) -> Option<&'a Operand<'tcx>> { + let const_ = l.constant()?; + if const_.literal.ty == self.tcx.types.bool + && const_.literal.val.try_to_bool() == Some(false) + { + if r.place().is_some() { + return Some(r); + } + } + + return None; + } } impl Visitor<'tcx> for OptimizationFinder<'b, 'tcx> { @@ -106,6 +128,18 @@ impl Visitor<'tcx> for OptimizationFinder<'b, 'tcx> { } } + // find Ne(_place, false) or Ne(false, _place) + if let Rvalue::BinaryOp(BinOp::Ne, l, r) = rvalue { + // (false, _place) + if let Some(o) = self.find_operand_in_ne_false_pattern(l, r) { + self.optimizations.unneeded_not_equal.insert(location, o.clone()); + } + // (_place, false) + else if let Some(o) = self.find_operand_in_ne_false_pattern(r, l) { + self.optimizations.unneeded_not_equal.insert(location, o.clone()); + } + } + self.super_rvalue(rvalue, location) } } @@ -114,4 +148,5 @@ impl Visitor<'tcx> for OptimizationFinder<'b, 'tcx> { struct OptimizationList<'tcx> { and_stars: FxHashSet, arrays_lengths: FxHashMap>, + unneeded_not_equal: FxHashMap>, } diff --git a/compiler/rustc_mir/src/transform/mod.rs b/compiler/rustc_mir/src/transform/mod.rs index c3a34756122a1..53f60baf0b675 100644 --- a/compiler/rustc_mir/src/transform/mod.rs +++ b/compiler/rustc_mir/src/transform/mod.rs @@ -453,8 +453,9 @@ fn run_optimization_passes<'tcx>( // The main optimizations that we do on MIR. let optimizations: &[&dyn MirPass<'tcx>] = &[ - &instcombine::InstCombine, &match_branches::MatchBranchSimplification, + // inst combine is after MatchBranchSimplification to clean up Ne(_1, false) + &instcombine::InstCombine, &const_prop::ConstProp, &simplify_branches::SimplifyBranches::new("after-const-prop"), &simplify_comparison_integral::SimplifyComparisonIntegral, diff --git a/src/test/mir-opt/not_equal_false.opt.InstCombine.diff b/src/test/mir-opt/not_equal_false.opt.InstCombine.diff new file mode 100644 index 0000000000000..d8621b90ad80d --- /dev/null +++ b/src/test/mir-opt/not_equal_false.opt.InstCombine.diff @@ -0,0 +1,72 @@ +- // MIR for `opt` before InstCombine ++ // MIR for `opt` after InstCombine + + fn opt(_1: Option<()>) -> bool { + debug x => _1; // in scope 0 at $DIR/not_equal_false.rs:3:8: 3:9 + let mut _0: bool; // return place in scope 0 at $DIR/not_equal_false.rs:3:26: 3:30 + let mut _2: bool; // in scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + let mut _3: isize; // in scope 0 at $DIR/not_equal_false.rs:4:17: 4:21 + let mut _4: bool; // in scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + let mut _5: isize; // in scope 0 at $DIR/not_equal_false.rs:4:38: 4:45 + + bb0: { + StorageLive(_2); // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + _3 = discriminant(_1); // scope 0 at $DIR/not_equal_false.rs:4:17: 4:21 + _2 = Eq(_3, const 0_isize); // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + goto -> bb7; // scope 0 at $DIR/not_equal_false.rs:4:17: 4:21 + } + + bb1: { + _0 = const true; // scope 0 at $DIR/not_equal_false.rs:4:5: 4:46 + goto -> bb4; // scope 0 at $DIR/not_equal_false.rs:4:5: 4:46 + } + + bb2: { + _0 = const false; // scope 0 at $DIR/not_equal_false.rs:4:5: 4:46 + goto -> bb4; // scope 0 at $DIR/not_equal_false.rs:4:5: 4:46 + } + + bb3: { + StorageLive(_4); // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + _5 = discriminant(_1); // scope 0 at $DIR/not_equal_false.rs:4:38: 4:45 + _4 = Eq(_5, const 1_isize); // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + goto -> bb10; // scope 0 at $DIR/not_equal_false.rs:4:38: 4:45 + } + + bb4: { + StorageDead(_4); // scope 0 at $DIR/not_equal_false.rs:4:45: 4:46 + StorageDead(_2); // scope 0 at $DIR/not_equal_false.rs:4:45: 4:46 + return; // scope 0 at $DIR/not_equal_false.rs:5:2: 5:2 + } + + bb5: { + _2 = const false; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + goto -> bb7; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + } + + bb6: { + _2 = const true; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + goto -> bb7; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + } + + bb7: { + switchInt(move _2) -> [false: bb3, otherwise: bb1]; // scope 0 at $DIR/not_equal_false.rs:4:5: 4:46 + } + + bb8: { + _4 = const false; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + goto -> bb10; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + } + + bb9: { + _4 = const true; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + goto -> bb10; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + } + + bb10: { +- _0 = Ne(_4, const false); // scope 0 at $DIR/not_equal_false.rs:4:5: 4:46 ++ _0 = _4; // scope 0 at $DIR/not_equal_false.rs:4:5: 4:46 + goto -> bb4; // scope 0 at $DIR/not_equal_false.rs:4:5: 4:46 + } + } + diff --git a/src/test/mir-opt/not_equal_false.rs b/src/test/mir-opt/not_equal_false.rs new file mode 100644 index 0000000000000..a98a2834e8ec9 --- /dev/null +++ b/src/test/mir-opt/not_equal_false.rs @@ -0,0 +1,9 @@ +// EMIT_MIR not_equal_false.opt.InstCombine.diff + +fn opt(x: Option<()>) -> bool { + matches!(x, None) || matches!(x, Some(_)) +} + +fn main() { + opt(None); +} From 9b0fc6202bf295e2518f7a781ca069c71c81698f Mon Sep 17 00:00:00 2001 From: Simon Vandel Sillesen Date: Thu, 3 Sep 2020 19:48:27 +0200 Subject: [PATCH 2/2] Generalize to Eq(true, _place) and Eq(_place, true) --- .../rustc_mir/src/transform/instcombine.rs | 45 ++++++++++++------- .../mir-opt/equal_true.opt.InstCombine.diff | 35 +++++++++++++++ src/test/mir-opt/equal_true.rs | 9 ++++ 3 files changed, 74 insertions(+), 15 deletions(-) create mode 100644 src/test/mir-opt/equal_true.opt.InstCombine.diff create mode 100644 src/test/mir-opt/equal_true.rs diff --git a/compiler/rustc_mir/src/transform/instcombine.rs b/compiler/rustc_mir/src/transform/instcombine.rs index 18cf2a2ff218b..c4924cf16ab64 100644 --- a/compiler/rustc_mir/src/transform/instcombine.rs +++ b/compiler/rustc_mir/src/transform/instcombine.rs @@ -66,7 +66,7 @@ impl<'tcx> MutVisitor<'tcx> for InstCombineVisitor<'tcx> { *rvalue = Rvalue::Use(Operand::Constant(box constant)); } - if let Some(operand) = self.optimizations.unneeded_not_equal.remove(&location) { + if let Some(operand) = self.optimizations.unneeded_equality_comparison.remove(&location) { debug!("replacing {:?} with {:?}", rvalue, operand); *rvalue = Rvalue::Use(operand); } @@ -87,14 +87,39 @@ impl OptimizationFinder<'b, 'tcx> { OptimizationFinder { body, tcx, optimizations: OptimizationList::default() } } - fn find_operand_in_ne_false_pattern( + fn find_unneeded_equality_comparison(&mut self, rvalue: &Rvalue<'tcx>, location: Location) { + // find Ne(_place, false) or Ne(false, _place) + // or Eq(_place, true) or Eq(true, _place) + if let Rvalue::BinaryOp(op, l, r) = rvalue { + let const_to_find = if *op == BinOp::Ne { + false + } else if *op == BinOp::Eq { + true + } else { + return; + }; + // (const, _place) + if let Some(o) = self.find_operand_in_equality_comparison_pattern(l, r, const_to_find) { + self.optimizations.unneeded_equality_comparison.insert(location, o.clone()); + } + // (_place, const) + else if let Some(o) = + self.find_operand_in_equality_comparison_pattern(r, l, const_to_find) + { + self.optimizations.unneeded_equality_comparison.insert(location, o.clone()); + } + } + } + + fn find_operand_in_equality_comparison_pattern( &self, l: &Operand<'tcx>, r: &'a Operand<'tcx>, + const_to_find: bool, ) -> Option<&'a Operand<'tcx>> { let const_ = l.constant()?; if const_.literal.ty == self.tcx.types.bool - && const_.literal.val.try_to_bool() == Some(false) + && const_.literal.val.try_to_bool() == Some(const_to_find) { if r.place().is_some() { return Some(r); @@ -128,17 +153,7 @@ impl Visitor<'tcx> for OptimizationFinder<'b, 'tcx> { } } - // find Ne(_place, false) or Ne(false, _place) - if let Rvalue::BinaryOp(BinOp::Ne, l, r) = rvalue { - // (false, _place) - if let Some(o) = self.find_operand_in_ne_false_pattern(l, r) { - self.optimizations.unneeded_not_equal.insert(location, o.clone()); - } - // (_place, false) - else if let Some(o) = self.find_operand_in_ne_false_pattern(r, l) { - self.optimizations.unneeded_not_equal.insert(location, o.clone()); - } - } + self.find_unneeded_equality_comparison(rvalue, location); self.super_rvalue(rvalue, location) } @@ -148,5 +163,5 @@ impl Visitor<'tcx> for OptimizationFinder<'b, 'tcx> { struct OptimizationList<'tcx> { and_stars: FxHashSet, arrays_lengths: FxHashMap>, - unneeded_not_equal: FxHashMap>, + unneeded_equality_comparison: FxHashMap>, } diff --git a/src/test/mir-opt/equal_true.opt.InstCombine.diff b/src/test/mir-opt/equal_true.opt.InstCombine.diff new file mode 100644 index 0000000000000..a26776e70d6b9 --- /dev/null +++ b/src/test/mir-opt/equal_true.opt.InstCombine.diff @@ -0,0 +1,35 @@ +- // MIR for `opt` before InstCombine ++ // MIR for `opt` after InstCombine + + fn opt(_1: bool) -> i32 { + debug x => _1; // in scope 0 at $DIR/equal_true.rs:3:8: 3:9 + let mut _0: i32; // return place in scope 0 at $DIR/equal_true.rs:3:20: 3:23 + let mut _2: bool; // in scope 0 at $DIR/equal_true.rs:4:8: 4:17 + let mut _3: bool; // in scope 0 at $DIR/equal_true.rs:4:8: 4:9 + + bb0: { + StorageLive(_2); // scope 0 at $DIR/equal_true.rs:4:8: 4:17 + StorageLive(_3); // scope 0 at $DIR/equal_true.rs:4:8: 4:9 + _3 = _1; // scope 0 at $DIR/equal_true.rs:4:8: 4:9 +- _2 = Eq(move _3, const true); // scope 0 at $DIR/equal_true.rs:4:8: 4:17 ++ _2 = move _3; // scope 0 at $DIR/equal_true.rs:4:8: 4:17 + StorageDead(_3); // scope 0 at $DIR/equal_true.rs:4:16: 4:17 + switchInt(_2) -> [false: bb1, otherwise: bb2]; // scope 0 at $DIR/equal_true.rs:4:5: 4:34 + } + + bb1: { + _0 = const 1_i32; // scope 0 at $DIR/equal_true.rs:4:31: 4:32 + goto -> bb3; // scope 0 at $DIR/equal_true.rs:4:5: 4:34 + } + + bb2: { + _0 = const 0_i32; // scope 0 at $DIR/equal_true.rs:4:20: 4:21 + goto -> bb3; // scope 0 at $DIR/equal_true.rs:4:5: 4:34 + } + + bb3: { + StorageDead(_2); // scope 0 at $DIR/equal_true.rs:5:1: 5:2 + return; // scope 0 at $DIR/equal_true.rs:5:2: 5:2 + } + } + diff --git a/src/test/mir-opt/equal_true.rs b/src/test/mir-opt/equal_true.rs new file mode 100644 index 0000000000000..994cd194a45e2 --- /dev/null +++ b/src/test/mir-opt/equal_true.rs @@ -0,0 +1,9 @@ +// EMIT_MIR equal_true.opt.InstCombine.diff + +fn opt(x: bool) -> i32 { + if x == true { 0 } else { 1 } +} + +fn main() { + opt(true); +}