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

@@ -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,
+        }
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////

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<Location>,
     arrays_lengths: FxHashMap<Location, Constant<'tcx>>,
+    unneeded_not_equal: FxHashMap<Location, Operand<'tcx>>,
 }

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,

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
+      }
+  }
+  

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);
+}