Auto merge of #149253 - saethlin:can-compare-bitwise, r=<try>

derive(PartialEq) via bitwise comparison where possible

Author: rust-bors[bot]

compiler/rustc_abi/src/layout/ty.rs

@@ -191,6 +191,29 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
         Ty::ty_and_layout_field(self, cx, i)
     }
 
+    pub fn is_pod_layout<C>(self, cx: &C) -> bool
+    where
+        Ty: TyAbiInterface<'a, C> + Copy,
+    {
+        let Variants::Single { .. } = self.variants else {
+            return false;
+        };
+
+        let mut expected_offset = Size::ZERO;
+        for i in self.fields.index_by_increasing_offset() {
+            if self.fields.offset(i) != expected_offset {
+                return false;
+            }
+            expected_offset = self.fields.offset(i) + TyAndLayout::field(self, cx, i).size;
+        }
+
+        if expected_offset != self.size {
+            return false;
+        }
+
+        true
+    }
+
     pub fn pointee_info_at<C>(self, cx: &C, offset: Size) -> Option<PointeeInfo>
     where
         Ty: TyAbiInterface<'a, C>,

compiler/rustc_builtin_macros/src/deriving/cmp/partial_eq.rs

@@ -1,6 +1,9 @@
-use rustc_ast::{BinOpKind, BorrowKind, Expr, ExprKind, MetaItem, Mutability, Safety};
+use rustc_ast::{
+    BinOpKind, BlockCheckMode, BorrowKind, Expr, ExprKind, GenericArg, MetaItem, MutTy, Mutability,
+    Safety, TyKind, UnsafeSource,
+};
 use rustc_expand::base::{Annotatable, ExtCtxt};
-use rustc_span::{Span, sym};
+use rustc_span::{Ident, Span, kw, sym};
 use thin_vec::thin_vec;
 
 use crate::deriving::generic::ty::*;
@@ -125,7 +128,7 @@ fn get_substructure_equality_expr(
 ) -> Box<Expr> {
     use SubstructureFields::*;
 
-    match substructure.fields {
+    let field_comparison = match substructure.fields {
         EnumMatching(.., fields) | Struct(.., fields) => {
             let combine = move |acc, field| {
                 let rhs = get_field_equality_expr(cx, field);
@@ -138,23 +141,35 @@ fn get_substructure_equality_expr(
                 Some(rhs)
             };
 
-            // First compare scalar fields, then compound fields, combining all
-            // with logical AND.
-            return fields
-                .iter()
-                .filter(|field| !field.maybe_scalar)
-                .fold(fields.iter().filter(|field| field.maybe_scalar).fold(None, combine), combine)
-                // If there are no fields, treat as always equal.
-                .unwrap_or_else(|| cx.expr_bool(span, true));
+            // If there are no fields, return true immediately.
+            // If there is just one, compare it.
+            // Otherwise, try to do a bitwise comparison.
+            match &fields[..] {
+                [] => return cx.expr_bool(span, true),
+                [field] => return get_field_equality_expr(cx, field),
+                _ => {
+                    // First compare scalar fields, then compound fields, combining all
+                    // with logical AND.
+                    fields
+                        .iter()
+                        .filter(|field| !field.maybe_scalar)
+                        .fold(
+                            fields.iter().filter(|field| field.maybe_scalar).fold(None, combine),
+                            combine,
+                        )
+                        .unwrap()
+                }
+            }
         }
         EnumDiscr(disc, match_expr) => {
             let lhs = get_field_equality_expr(cx, disc);
-            let Some(match_expr) = match_expr else {
-                return lhs;
-            };
-            // Compare the discriminant first (cheaper), then the rest of the
-            // fields.
-            return cx.expr_binary(disc.span, BinOpKind::And, lhs, match_expr.clone());
+            if let Some(match_expr) = match_expr {
+                // Compare the discriminant first (cheaper), then the rest of the
+                // fields.
+                cx.expr_binary(disc.span, BinOpKind::And, lhs, match_expr.clone())
+            } else {
+                lhs
+            }
         }
         StaticEnum(..) => cx.dcx().span_bug(
             span,
@@ -168,6 +183,55 @@ fn get_substructure_equality_expr(
             span,
             "unexpected all-fieldless enum encountered during `derive(PartialEq)` expansion",
         ),
+    };
+
+    if matches!(substructure.fields, Struct(..)) {
+        // Construct intrinsics::can_compare_bitwise<Self>()
+        let self_ty = cx.ty_path(cx.path_ident(span, Ident::with_dummy_span(kw::SelfUpper)));
+        let path = cx.expr_path(cx.path_all(
+            span,
+            true,
+            cx.std_path(&[sym::intrinsics, sym::can_compare_bitwise]),
+            vec![GenericArg::Type(self_ty.clone())],
+        ));
+        let cond = cx.expr_call(span, path, thin_vec![]);
+
+        let [_self, rhs] = &substructure.selflike_args[..] else {
+            cx.dcx().span_bug(span, "not exactly 2 arguments in `derive(PartialEq)`");
+        };
+
+        // Construct intrinsics::compare_bitwise(
+        //     self as *const Self as *const u8,
+        //     other as *const Self as *const u8,
+        //
+        // );
+        let self_ptr_ty = cx.ty(span, TyKind::Ptr(MutTy { ty: self_ty, mutbl: Mutability::Not }));
+        let u8_ty = cx.ty_ident(span, Ident::with_dummy_span(sym::u8));
+        let u8_ptr_ty = cx.ty(span, TyKind::Ptr(MutTy { ty: u8_ty, mutbl: Mutability::Not }));
+
+        let self_ptr = cx.expr_cast(span, cx.expr_self(span), self_ptr_ty.clone());
+        let self_ptr_u8 = cx.expr_cast(span, self_ptr, u8_ptr_ty.clone());
+
+        let other_ptr = cx.expr_cast(span, rhs.clone(), self_ptr_ty);
+        let other_ptr_u8 = cx.expr_cast(span, other_ptr, u8_ptr_ty);
+
+        let size_of_val = cx.std_path(&[sym::intrinsics, sym::size_of_val]);
+        let size = cx.expr_call_global(span, size_of_val, thin_vec![cx.expr_self(span)]);
+
+        let compare_bytes = cx.std_path(&[sym::intrinsics, sym::compare_bytes]);
+
+        let call_compare_bytes =
+            cx.expr_call_global(span, compare_bytes, thin_vec![self_ptr_u8, other_ptr_u8, size]);
+
+        let mut call = cx.block_expr(call_compare_bytes);
+        call.rules = BlockCheckMode::Unsafe(UnsafeSource::CompilerGenerated);
+        let call = cx.expr_block(call);
+
+        let is_eq = cx.expr_binary(span, BinOpKind::Eq, call, cx.expr_i32(span, 0));
+
+        cx.expr_if(span, cond, is_eq, Some(field_comparison))
+    } else {
+        field_comparison
     }
 }
 

compiler/rustc_builtin_macros/src/deriving/generic/mod.rs

@@ -278,6 +278,7 @@ pub(crate) struct Substructure<'a> {
     /// Verbatim access to any non-selflike arguments, i.e. arguments that
     /// don't have type `&Self`.
     pub nonselflike_args: &'a [Box<Expr>],
+    pub selflike_args: &'a [Box<Expr>],
     pub fields: &'a SubstructureFields<'a>,
 }
 
@@ -879,6 +880,7 @@ impl<'a> TraitDef<'a> {
                         self,
                         struct_def,
                         type_ident,
+                        &selflike_args,
                         &nonselflike_args,
                     )
                 } else {
@@ -935,6 +937,7 @@ impl<'a> TraitDef<'a> {
                         self,
                         enum_def,
                         type_ident,
+                        &selflike_args,
                         &nonselflike_args,
                     )
                 } else {
@@ -971,11 +974,12 @@ impl<'a> MethodDef<'a> {
         cx: &ExtCtxt<'_>,
         trait_: &TraitDef<'_>,
         type_ident: Ident,
+        selflike_args: &[Box<Expr>],
         nonselflike_args: &[Box<Expr>],
         fields: &SubstructureFields<'_>,
     ) -> BlockOrExpr {
         let span = trait_.span;
-        let substructure = Substructure { type_ident, nonselflike_args, fields };
+        let substructure = Substructure { type_ident, selflike_args, nonselflike_args, fields };
         let mut f = self.combine_substructure.borrow_mut();
         let f: &mut CombineSubstructureFunc<'_> = &mut *f;
         f(cx, span, &substructure)
@@ -1150,6 +1154,7 @@ impl<'a> MethodDef<'a> {
             cx,
             trait_,
             type_ident,
+            selflike_args,
             nonselflike_args,
             &Struct(struct_def, selflike_fields),
         )
@@ -1161,6 +1166,7 @@ impl<'a> MethodDef<'a> {
         trait_: &TraitDef<'_>,
         struct_def: &VariantData,
         type_ident: Ident,
+        selflike_args: &[Box<Expr>],
         nonselflike_args: &[Box<Expr>],
     ) -> BlockOrExpr {
         let summary = trait_.summarise_struct(cx, struct_def);
@@ -1169,6 +1175,7 @@ impl<'a> MethodDef<'a> {
             cx,
             trait_,
             type_ident,
+            selflike_args,
             nonselflike_args,
             &StaticStruct(struct_def, summary),
         )
@@ -1305,6 +1312,7 @@ impl<'a> MethodDef<'a> {
                             cx,
                             trait_,
                             type_ident,
+                            &selflike_args,
                             nonselflike_args,
                             &EnumDiscr(discr_field, None),
                         );
@@ -1316,6 +1324,7 @@ impl<'a> MethodDef<'a> {
                             cx,
                             trait_,
                             type_ident,
+                            &selflike_args,
                             nonselflike_args,
                             &AllFieldlessEnum(enum_def),
                         );
@@ -1329,6 +1338,7 @@ impl<'a> MethodDef<'a> {
                     cx,
                     trait_,
                     type_ident,
+                    &selflike_args,
                     nonselflike_args,
                     &EnumMatching(variant, Vec::new()),
                 );
@@ -1381,6 +1391,7 @@ impl<'a> MethodDef<'a> {
                         cx,
                         trait_,
                         type_ident,
+                        &selflike_args,
                         nonselflike_args,
                         &substructure,
                     )
@@ -1402,6 +1413,7 @@ impl<'a> MethodDef<'a> {
                         cx,
                         trait_,
                         type_ident,
+                        &selflike_args,
                         nonselflike_args,
                         &EnumMatching(v, Vec::new()),
                     )
@@ -1448,6 +1460,7 @@ impl<'a> MethodDef<'a> {
                 cx,
                 trait_,
                 type_ident,
+                &selflike_args.clone(),
                 nonselflike_args,
                 &EnumDiscr(discr_field, Some(get_match_expr(selflike_args))),
             );
@@ -1464,12 +1477,14 @@ impl<'a> MethodDef<'a> {
         trait_: &TraitDef<'_>,
         enum_def: &EnumDef,
         type_ident: Ident,
+        selflike_args: &[Box<Expr>],
         nonselflike_args: &[Box<Expr>],
     ) -> BlockOrExpr {
         self.call_substructure_method(
             cx,
             trait_,
             type_ident,
+            selflike_args,
             nonselflike_args,
             &StaticEnum(enum_def),
         )

compiler/rustc_expand/src/build.rs

@@ -394,6 +394,11 @@ impl<'a> ExtCtxt<'a> {
         let pathexpr = self.expr_path(self.path_global(sp, fn_path));
         self.expr_call(sp, pathexpr, args)
     }
+
+    pub fn expr_cast(&self, span: Span, src: Box<Expr>, ty: Box<ast::Ty>) -> Box<Expr> {
+        self.expr(span, ast::ExprKind::Cast(src, ty))
+    }
+
     pub fn expr_block(&self, b: Box<ast::Block>) -> Box<ast::Expr> {
         self.expr(b.span, ast::ExprKind::Block(b, None))
     }
@@ -445,6 +450,12 @@ impl<'a> ExtCtxt<'a> {
         self.expr(span, ast::ExprKind::Lit(lit))
     }
 
+    pub fn expr_i32(&self, span: Span, n: u32) -> Box<ast::Expr> {
+        let suffix = Some(ast::IntTy::I32.name());
+        let lit = token::Lit::new(token::Integer, sym::integer(n), suffix);
+        self.expr(span, ast::ExprKind::Lit(lit))
+    }
+
     pub fn expr_bool(&self, span: Span, value: bool) -> Box<ast::Expr> {
         let lit = token::Lit::new(token::Bool, if value { kw::True } else { kw::False }, None);
         self.expr(span, ast::ExprKind::Lit(lit))

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -80,12 +80,14 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::breakpoint
         | sym::bswap
         | sym::caller_location
+        | sym::can_compare_bitwise
         | sym::carrying_mul_add
         | sym::ceilf16
         | sym::ceilf32
         | sym::ceilf64
         | sym::ceilf128
         | sym::cold_path
+        | sym::compare_bitwise
         | sym::const_eval_select
         | sym::contract_check_ensures
         | sym::contract_check_requires
@@ -342,6 +344,18 @@ pub(crate) fn check_intrinsic_type(
             vec![Ty::new_mut_ptr(tcx, param(0)), Ty::new_imm_ptr(tcx, param(0)), tcx.types.usize],
             tcx.types.unit,
         ),
+        sym::compare_bitwise => {
+            let br = ty::BoundRegion { var: ty::BoundVar::ZERO, kind: ty::BoundRegionKind::Anon };
+            let first_arg =
+                Ty::new_imm_ref(tcx, ty::Region::new_bound(tcx, ty::INNERMOST, br), param(0));
+            let br =
+                ty::BoundRegion { var: ty::BoundVar::from_u32(1), kind: ty::BoundRegionKind::Anon };
+            let second_arg =
+                Ty::new_imm_ref(tcx, ty::Region::new_bound(tcx, ty::INNERMOST, br), param(0));
+
+            (1, 0, vec![first_arg, second_arg], tcx.types.bool)
+        }
+        sym::can_compare_bitwise => (1, 0, vec![], tcx.types.bool),
         sym::compare_bytes => {
             let byte_ptr = Ty::new_imm_ptr(tcx, tcx.types.u8);
             (0, 0, vec![byte_ptr, byte_ptr, tcx.types.usize], tcx.types.i32)

compiler/rustc_middle/src/ty/sty.rs

@@ -1987,6 +1987,14 @@ impl<'tcx> Ty<'tcx> {
         }
     }
 
+    pub fn is_pod(self, tcx: TyCtxt<'tcx>) -> bool {
+        match self.kind() {
+            ty::Int(..) | ty::Uint(..) | ty::Bool | ty::Char => true,
+            ty::Array(element_ty, _len) => element_ty.is_pod(tcx),
+            _ => false,
+        }
+    }
+
     pub fn is_trivially_wf(self, tcx: TyCtxt<'tcx>) -> bool {
         match *self.kind() {
             ty::Bool

compiler/rustc_mir_transform/src/known_panics_lint.rs

@@ -255,6 +255,11 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
             return None;
         }
 
+        // Don't try to evaluate the Operand::Const of calls to a concrete fn
+        if matches!(c.ty().kind(), ty::FnDef(..)) {
+            return None;
+        }
+
         // Normalization needed b/c known panics lint runs in
         // `mir_drops_elaborated_and_const_checked`, which happens before
         // optimized MIR. Only after optimizing the MIR can we guarantee