Implement algebraic simplifications.

Author: cjgillot

compiler/rustc_mir_transform/src/dataflow_const_prop.rs

@@ -344,18 +344,45 @@ impl<'a, 'm, 'tcx> ConstAnalysis<'a, 'm, 'tcx> {
     ) -> (FlatSet<ScalarTy<'tcx>>, FlatSet<bool>) {
         let left = self.eval_operand(left, state);
         let right = self.eval_operand(right, state);
+
         match (left, right) {
+            (FlatSet::Bottom, _) | (_, FlatSet::Bottom) => (FlatSet::Bottom, FlatSet::Bottom),
+            // Both sides are known, do the actual computation.
             (FlatSet::Elem(left), FlatSet::Elem(right)) => {
                 match self.ecx.overflowing_binary_op(op, &left, &right) {
                     Ok((val, overflow, ty)) => (self.wrap_scalar(val, ty), FlatSet::Elem(overflow)),
                     _ => (FlatSet::Top, FlatSet::Top),
                 }
             }
-            (FlatSet::Bottom, _) | (_, FlatSet::Bottom) => (FlatSet::Bottom, FlatSet::Bottom),
-            (_, _) => {
-                // Could attempt some algebraic simplifications here.
-                (FlatSet::Top, FlatSet::Top)
+            // Exactly one side is known, attempt some algebraic simplifications.
+            (FlatSet::Elem(const_arg), _) | (_, FlatSet::Elem(const_arg)) => {
+                let layout = const_arg.layout;
+                if !matches!(layout.abi, rustc_target::abi::Abi::Scalar(..)) {
+                    return (FlatSet::Top, FlatSet::Top);
+                }
+
+                let arg_scalar = const_arg.to_scalar();
+                let Ok(arg_value) = arg_scalar.to_bits(layout.size) else {
+                    return (FlatSet::Top, FlatSet::Top);
+                };
+
+                match op {
+                    BinOp::BitAnd if arg_value == 0 => {
+                        (self.wrap_scalar(arg_scalar, layout.ty), FlatSet::Bottom)
+                    }
+                    BinOp::BitOr
+                        if arg_value == layout.size.truncate(u128::MAX)
+                            || (layout.ty.is_bool() && arg_value == 1) =>
+                    {
+                        (self.wrap_scalar(arg_scalar, layout.ty), FlatSet::Bottom)
+                    }
+                    BinOp::Mul if layout.ty.is_integral() && arg_value == 0 => {
+                        (self.wrap_scalar(arg_scalar, layout.ty), FlatSet::Elem(false))
+                    }
+                    _ => (FlatSet::Top, FlatSet::Top),
+                }
             }
+            (FlatSet::Top, FlatSet::Top) => (FlatSet::Top, FlatSet::Top),
         }
     }
 

tests/mir-opt/const_prop/boolean_identities.test.ConstProp.diff

@@ -12,10 +12,13 @@
 
       bb0: {
           StorageLive(_3);
-          _3 = BitOr(_2, const true);
+-         _3 = BitOr(_2, const true);
++         _3 = const true;
           StorageLive(_5);
-          _5 = BitAnd(_1, const false);
-          _0 = BitAnd(move _3, move _5);
+-         _5 = BitAnd(_1, const false);
+-         _0 = BitAnd(move _3, move _5);
++         _5 = const false;
++         _0 = const false;
           StorageDead(_5);
           StorageDead(_3);
           return;

tests/mir-opt/const_prop/mult_by_zero.test.ConstProp.diff

@@ -9,7 +9,8 @@
       bb0: {
           StorageLive(_2);
           _2 = _1;
-          _0 = Mul(move _2, const 0_i32);
+-         _0 = Mul(move _2, const 0_i32);
++         _0 = const 0_i32;
           StorageDead(_2);
           return;
       }