Make all constants of primitive type deterministic.

cjgillot · cjgillot · commit 58689f288da2 · 2025-10-04T16:36:58.000Z
diff --git a/compiler/rustc_middle/src/mir/consts.rs b/compiler/rustc_middle/src/mir/consts.rs
@@ -495,6 +495,11 @@ impl<'tcx> Const<'tcx> {
     /// Return true if any evaluation of this constant always returns the same value,
     /// taking into account even pointer identity tests.
     pub fn is_deterministic(&self) -> bool {
+        if self.ty().is_primitive() {
+            // Primitive types hold no provenance, so their result is deterministic.
+            return true;
+        }
+
         // Some constants may generate fresh allocations for pointers they contain,
         // so using the same constant twice can yield two different results.
         // Notably, valtrees purposefully generate new allocations.
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
@@ -982,16 +982,16 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
         operand: &mut Operand<'tcx>,
         location: Location,
     ) -> Option<VnIndex> {
-        match *operand {
-            Operand::Constant(ref constant) => Some(self.insert_constant(constant.const_)),
+        let value = match *operand {
+            Operand::Constant(ref constant) => self.insert_constant(constant.const_),
             Operand::Copy(ref mut place) | Operand::Move(ref mut place) => {
-                let value = self.simplify_place_value(place, location)?;
-                if let Some(const_) = self.try_as_constant(value) {
-                    *operand = Operand::Constant(Box::new(const_));
-                }
-                Some(value)
+                self.simplify_place_value(place, location)?
             }
+        };
+        if let Some(const_) = self.try_as_constant(value) {
+            *operand = Operand::Constant(Box::new(const_));
         }
+        Some(value)
     }
 
     #[instrument(level = "trace", skip(self), ret)]
@@ -1762,14 +1762,30 @@ impl<'tcx> VnState<'_, '_, 'tcx> {
 
     /// If `index` is a `Value::Constant`, return the `Constant` to be put in the MIR.
     fn try_as_constant(&mut self, index: VnIndex) -> Option<ConstOperand<'tcx>> {
-        // This was already constant in MIR, do not change it. If the constant is not
-        // deterministic, adding an additional mention of it in MIR will not give the same value as
-        // the former mention.
-        if let Value::Constant { value, disambiguator: None } = self.get(index) {
+        let value = self.get(index);
+
+        // This was already an *evaluated* constant in MIR, do not change it.
+        if let Value::Constant { value, disambiguator: None } = value
+            && let Const::Val(..) = value
+        {
+            debug_assert!(value.is_deterministic());
+            return Some(ConstOperand { span: DUMMY_SP, user_ty: None, const_: value });
+        }
+
+        if let Some(value) = self.try_as_evaluated_constant(index) {
+            return Some(ConstOperand { span: DUMMY_SP, user_ty: None, const_: value });
+        }
+
+        // We failed to provide an evaluated form, fallback to using the unevaluated constant.
+        if let Value::Constant { value, disambiguator: None } = value {
             debug_assert!(value.is_deterministic());
             return Some(ConstOperand { span: DUMMY_SP, user_ty: None, const_: value });
         }
 
+        None
+    }
+
+    fn try_as_evaluated_constant(&mut self, index: VnIndex) -> Option<Const<'tcx>> {
         let op = self.evaluated[index].as_ref()?;
         if op.layout.is_unsized() {
             // Do not attempt to propagate unsized locals.
@@ -1783,8 +1799,7 @@ impl<'tcx> VnState<'_, '_, 'tcx> {
         // FIXME: remove this hack once https://github.com/rust-lang/rust/issues/79738 is fixed.
         assert!(!value.may_have_provenance(self.tcx, op.layout.size));
 
-        let const_ = Const::Val(value, op.layout.ty);
-        Some(ConstOperand { span: DUMMY_SP, user_ty: None, const_ })
+        Some(Const::Val(value, op.layout.ty))
     }
 
     /// Construct a place which holds the same value as `index` and for which all locals strictly
diff --git a/tests/mir-opt/building/match/sort_candidates.rs b/tests/mir-opt/building/match/sort_candidates.rs
@@ -1,12 +1,13 @@
-// Check specific cases of sorting candidates in match lowering.
+//! Check specific cases of sorting candidates in match lowering.
+//@ compile-flags: -Zmir-opt-level=0
 
 // EMIT_MIR sort_candidates.constant_eq.SimplifyCfg-initial.after.mir
 fn constant_eq(s: &str, b: bool) -> u32 {
     // Check that we only test "a" once
 
     // CHECK-LABEL: fn constant_eq(
     // CHECK-NOT: const "a"
-    // CHECK: {{_[0-9]+}} = const "a" as &[u8] (Transmute);
+    // CHECK: eq({{.*}}, const "a")
     // CHECK-NOT: const "a"
     match (s, b) {
         ("a", _) if true => 1,
@@ -23,11 +24,16 @@ fn disjoint_ranges(x: i32, b: bool) -> u32 {
     // other candidates.
 
     // CHECK-LABEL: fn disjoint_ranges(
-    // CHECK: debug b => _2;
-    // CHECK: bb0: {
-    // CHECK: switchInt(copy _2) -> [0: [[jump:bb.*]], otherwise: {{bb.*}}];
+    // CHECK: debug b => [[b:_.*]];
+    // CHECK: [[tmp:_.*]] = copy [[b]];
+    // CHECK-NEXT: switchInt(move [[tmp]]) -> [0: [[jump:bb.*]], otherwise: {{bb.*}}];
     // CHECK: [[jump]]: {
+    // CHECK-NEXT: StorageDead([[tmp]]);
+    // CHECK-NEXT: goto -> [[jump3:bb.*]];
+    // CHECK: [[jump3]]: {
     // CHECK-NEXT: _0 = const 3_u32;
+    // CHECK-NEXT: goto -> [[jumpret:bb.*]];
+    // CHECK: [[jumpret]]: {
     // CHECK-NEXT: return;
     match x {
         0..10 if b => 0,
diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-abort.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-abort.diff
@@ -47,7 +47,7 @@
           StorageLive(_20);
           StorageLive(_21);
           _21 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
-          _20 = BitAnd(move _21, const core::fmt::flags::SIGN_PLUS_FLAG);
+          _20 = BitAnd(move _21, const 2097152_u32);
           StorageDead(_21);
           _4 = Ne(move _20, const 0_u32);
           StorageDead(_20);
@@ -72,7 +72,7 @@
           StorageLive(_22);
           StorageLive(_23);
           _23 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
-          _22 = BitAnd(move _23, const core::fmt::flags::PRECISION_FLAG);
+          _22 = BitAnd(move _23, const 268435456_u32);
           StorageDead(_23);
           switchInt(move _22) -> [0: bb10, otherwise: bb11];
       }
diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-unwind.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-unwind.diff
@@ -47,7 +47,7 @@
           StorageLive(_20);
           StorageLive(_21);
           _21 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
-          _20 = BitAnd(move _21, const core::fmt::flags::SIGN_PLUS_FLAG);
+          _20 = BitAnd(move _21, const 2097152_u32);
           StorageDead(_21);
           _4 = Ne(move _20, const 0_u32);
           StorageDead(_20);
@@ -72,7 +72,7 @@
           StorageLive(_22);
           StorageLive(_23);
           _23 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
-          _22 = BitAnd(move _23, const core::fmt::flags::PRECISION_FLAG);
+          _22 = BitAnd(move _23, const 268435456_u32);
           StorageDead(_23);
           switchInt(move _22) -> [0: bb10, otherwise: bb11];
       }
diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-abort.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-abort.diff
@@ -47,7 +47,7 @@
           StorageLive(_20);
           StorageLive(_21);
           _21 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
-          _20 = BitAnd(move _21, const core::fmt::flags::SIGN_PLUS_FLAG);
+          _20 = BitAnd(move _21, const 2097152_u32);
           StorageDead(_21);
           _4 = Ne(move _20, const 0_u32);
           StorageDead(_20);
@@ -72,7 +72,7 @@
           StorageLive(_22);
           StorageLive(_23);
           _23 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
-          _22 = BitAnd(move _23, const core::fmt::flags::PRECISION_FLAG);
+          _22 = BitAnd(move _23, const 268435456_u32);
           StorageDead(_23);
           switchInt(move _22) -> [0: bb10, otherwise: bb11];
       }
diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-unwind.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-unwind.diff
@@ -47,7 +47,7 @@
           StorageLive(_20);
           StorageLive(_21);
           _21 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
-          _20 = BitAnd(move _21, const core::fmt::flags::SIGN_PLUS_FLAG);
+          _20 = BitAnd(move _21, const 2097152_u32);
           StorageDead(_21);
           _4 = Ne(move _20, const 0_u32);
           StorageDead(_20);
@@ -72,7 +72,7 @@
           StorageLive(_22);
           StorageLive(_23);
           _23 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
-          _22 = BitAnd(move _23, const core::fmt::flags::PRECISION_FLAG);
+          _22 = BitAnd(move _23, const 268435456_u32);
           StorageDead(_23);
           switchInt(move _22) -> [0: bb10, otherwise: bb11];
       }
diff --git a/tests/mir-opt/gvn_const_eval_polymorphic.no_optimize.GVN.diff b/tests/mir-opt/gvn_const_eval_polymorphic.no_optimize.GVN.diff
@@ -5,7 +5,8 @@
       let mut _0: bool;
   
       bb0: {
-          _0 = Eq(const no_optimize::<T>::{constant#0}, const no_optimize::<T>::{constant#1});
+-         _0 = Eq(const no_optimize::<T>::{constant#0}, const no_optimize::<T>::{constant#1});
++         _0 = Eq(const no_optimize::<T>::{constant#0}, const true);
           return;
       }
   }
diff --git a/tests/mir-opt/gvn_const_eval_polymorphic.rs b/tests/mir-opt/gvn_const_eval_polymorphic.rs
@@ -51,7 +51,7 @@ fn optimize_false<T>() -> bool {
 // EMIT_MIR gvn_const_eval_polymorphic.no_optimize.GVN.diff
 fn no_optimize<T>() -> bool {
     // CHECK-LABEL: fn no_optimize(
-    // CHECK: _0 = Eq(const no_optimize::<T>::{constant#0}, const no_optimize::<T>::{constant#1});
+    // CHECK: _0 = Eq(const no_optimize::<T>::{constant#0}, const true);
     // CHECK-NEXT: return;
     (const { type_name_contains_i32(&generic::<T>) }) == const { true }
 }
diff --git a/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-abort.mir
@@ -17,7 +17,7 @@ fn checked_shl(_1: u32, _2: u32) -> Option<u32> {
 
     bb0: {
         StorageLive(_3);
-        _3 = Lt(copy _2, const core::num::<impl u32>::BITS);
+        _3 = Lt(copy _2, const 32_u32);
         switchInt(move _3) -> [0: bb1, otherwise: bb2];
     }
 
diff --git a/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-unwind.mir
@@ -17,7 +17,7 @@ fn checked_shl(_1: u32, _2: u32) -> Option<u32> {
 
     bb0: {
         StorageLive(_3);
-        _3 = Lt(copy _2, const core::num::<impl u32>::BITS);
+        _3 = Lt(copy _2, const 32_u32);
         switchInt(move _3) -> [0: bb1, otherwise: bb2];
     }
 
diff --git a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-abort.mir
@@ -72,7 +72,7 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
     }
 
     bb6: {
-        assert(!const true, "attempt to compute `{} + {}`, which would overflow", const core::num::<impl u16>::MAX, const 1_u16) -> [success: bb7, unwind unreachable];
+        assert(!const true, "attempt to compute `{} + {}`, which would overflow", const u16::MAX, const 1_u16) -> [success: bb7, unwind unreachable];
     }
 
     bb7: {
diff --git a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-unwind.mir
@@ -72,7 +72,7 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
     }
 
     bb6: {
-        assert(!const true, "attempt to compute `{} + {}`, which would overflow", const core::num::<impl u16>::MAX, const 1_u16) -> [success: bb7, unwind continue];
+        assert(!const true, "attempt to compute `{} + {}`, which would overflow", const u16::MAX, const 1_u16) -> [success: bb7, unwind continue];
     }
 
     bb7: {

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,8 @@`
`5`	`5`	`let mut _0: bool;`
`6`	`6`
`7`	`7`	`bb0: {`
`8`		`- _0 = Eq(const no_optimize::<T>::{constant#0}, const no_optimize::<T>::{constant#1});`
	`8`	`+- _0 = Eq(const no_optimize::<T>::{constant#0}, const no_optimize::<T>::{constant#1});`
	`9`	`++ _0 = Eq(const no_optimize::<T>::{constant#0}, const true);`
`9`	`10`	`return;`
`10`	`11`	`}`
`11`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ fn optimize_false<T>() -> bool {`
`51`	`51`	`// EMIT_MIR gvn_const_eval_polymorphic.no_optimize.GVN.diff`
`52`	`52`	`fn no_optimize<T>() -> bool {`
`53`	`53`	`// CHECK-LABEL: fn no_optimize(`
`54`		`- // CHECK: _0 = Eq(const no_optimize::<T>::{constant#0}, const no_optimize::<T>::{constant#1});`
	`54`	`+ // CHECK: _0 = Eq(const no_optimize::<T>::{constant#0}, const true);`
`55`	`55`	`// CHECK-NEXT: return;`
`56`	`56`	`(const { type_name_contains_i32(&generic::<T>) }) == const { true }`
`57`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ fn checked_shl(_1: u32, _2: u32) -> Option<u32> {`
`17`	`17`
`18`	`18`	`bb0: {`
`19`	`19`	`StorageLive(_3);`
`20`		`- _3 = Lt(copy _2, const core::num::<impl u32>::BITS);`
	`20`	`+ _3 = Lt(copy _2, const 32_u32);`
`21`	`21`	`switchInt(move _3) -> [0: bb1, otherwise: bb2];`
`22`	`22`	`}`
`23`	`23`