Update compiler/rustc_const_eval/src/const_eval/machine.rs

Co-authored-by: Ralf Jung <[email protected]>

Author: zachs18

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -280,16 +280,8 @@ impl<'tcx> CompileTimeInterpCx<'tcx> {
         interp_ok(match (a, b) {
             // Comparisons between integers are always known.
             (Scalar::Int(a), Scalar::Int(b)) => (a == b) as u8,
-            // A pointer can be known to be unequal to an integer if them being equal would imply
-            // that the null pointer is in-bounds (including one-past-the-end) of the pointer's
-            // allocation (as the null pointer is never in-bounds of any allocation), or is
-            // misaligned (as `0` is a multiple of any alignment), or that the pointer's
-            // allocation would wrap around the address space.
-            // Concretely, if `scalar_may_be_null` indicates that `ptr.wrapping_sub(int)` cannot
-            // be equal to `0`, then we know that `ptr != int`.
-            // For the specific case where `int == 0`, this checks if the pointer itself
-            // can definitely not be null, and this behavior is exposed on stable as
-            // `pointer::is_null`.
+            // Comparing a pointer `ptr` with an integer `int` is equivalent to comparing
+            // `ptr-int` with null, so we can reduce this case to a `scalar_may_be_null` test.
             (Scalar::Int(int), Scalar::Ptr(ptr, _)) | (Scalar::Ptr(ptr, _), Scalar::Int(int)) => {
                 let int = int.to_target_usize(*self.tcx);
                 let offset_ptr = ptr.wrapping_offset(Size::from_bytes(int.wrapping_neg()), self);