Auto merge of rust-lang#104862 - saethlin:mir-niche-checks, r=<try>

Check for occupied niches

Implementation of rust-lang/compiler-team#624

Crater run has 62 crates that hit the check, 43 of those are published to crates.io. I see a lot of null function pointers and use of `mem::uninitialized` where the 0x1-filling collides with an enum niche.

But that is with full niche checks; checking transmute, plus any place where that we Copy, Move, or Inspect. Such checking is definitely too thorough to be on by default because it is 2x compile time overhead.

r? `@ghost`

Author: bors

compiler/rustc_codegen_cranelift/src/base.rs

@@ -368,6 +368,29 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
                             source_info.span,
                         );
                     }
+                    AssertKind::OccupiedNiche {
+                        ref found,
+                        ref start,
+                        ref end,
+                        ref type_name,
+                        ref offset,
+                        ref niche_ty,
+                    } => {
+                        let found = codegen_operand(fx, found).load_scalar(fx);
+                        let start = codegen_operand(fx, start).load_scalar(fx);
+                        let end = codegen_operand(fx, end).load_scalar(fx);
+                        let type_name = fx.anonymous_str(type_name);
+                        let offset = codegen_operand(fx, offset).load_scalar(fx);
+                        let niche_ty = fx.anonymous_str(niche_ty);
+                        let location = fx.get_caller_location(source_info).load_scalar(fx);
+
+                        codegen_panic_inner(
+                            fx,
+                            rustc_hir::LangItem::PanicOccupiedNiche,
+                            &[found, start, end, type_name, offset, niche_ty, location],
+                            source_info.span,
+                        )
+                    }
                     _ => {
                         let msg_str = msg.description();
                         codegen_panic(fx, msg_str, source_info);

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -624,6 +624,35 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 // and `#[track_caller]` adds an implicit third argument.
                 (LangItem::PanicMisalignedPointerDereference, vec![required, found, location])
             }
+            AssertKind::OccupiedNiche {
+                ref found,
+                ref start,
+                ref end,
+                ref type_name,
+                ref offset,
+                ref niche_ty,
+            } => {
+                let found = self.codegen_operand(bx, found).immediate();
+                let start = self.codegen_operand(bx, start).immediate();
+                let end = self.codegen_operand(bx, end).immediate();
+                let type_name = bx.const_str(type_name);
+                let offset = self.codegen_operand(bx, offset).immediate();
+                let niche_ty = bx.const_str(niche_ty);
+                (
+                    LangItem::PanicOccupiedNiche,
+                    vec![
+                        found,
+                        start,
+                        end,
+                        type_name.0,
+                        type_name.1,
+                        offset,
+                        niche_ty.0,
+                        niche_ty.1,
+                        location,
+                    ],
+                )
+            }
             _ => {
                 let msg = bx.const_str(msg.description());
                 // It's `pub fn panic(expr: &str)`, with the wide reference being passed

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -542,6 +542,21 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
                     found: eval_to_int(found)?,
                 }
             }
+            OccupiedNiche {
+                ref found,
+                ref start,
+                ref end,
+                ref type_name,
+                ref offset,
+                ref niche_ty,
+            } => OccupiedNiche {
+                found: eval_to_int(found)?,
+                start: eval_to_int(start)?,
+                end: eval_to_int(end)?,
+                type_name: type_name.clone(),
+                offset: eval_to_int(offset)?,
+                niche_ty: niche_ty.clone(),
+            },
         };
         Err(ConstEvalErrKind::AssertFailure(err).into())
     }

compiler/rustc_hir/src/lang_items.rs

@@ -234,6 +234,7 @@ language_item_table! {
     ConstPanicFmt,           sym::const_panic_fmt,     const_panic_fmt,            Target::Fn,             GenericRequirement::None;
     PanicBoundsCheck,        sym::panic_bounds_check,  panic_bounds_check_fn,      Target::Fn,             GenericRequirement::Exact(0);
     PanicMisalignedPointerDereference,        sym::panic_misaligned_pointer_dereference,  panic_misaligned_pointer_dereference_fn,      Target::Fn,             GenericRequirement::Exact(0);
+    PanicOccupiedNiche,      sym::panic_occupied_niche, panic_occupied_niche_fn,      Target::Fn,             GenericRequirement::Exact(0);
     PanicInfo,               sym::panic_info,          panic_info,                 Target::Struct,         GenericRequirement::None;
     PanicLocation,           sym::panic_location,      panic_location,             Target::Struct,         GenericRequirement::None;
     PanicImpl,               sym::panic_impl,          panic_impl,                 Target::Fn,             GenericRequirement::None;

compiler/rustc_middle/messages.ftl

@@ -15,6 +15,9 @@ middle_assert_divide_by_zero =
 middle_assert_misaligned_ptr_deref =
     misaligned pointer dereference: address must be a multiple of {$required} but is {$found}
 
+middle_assert_occupied_niche =
+    occupied niche: {$found} must be in {$start}..={$end}
+
 middle_assert_op_overflow =
     attempt to compute `{$left} {$op} {$right}`, which would overflow
 

compiler/rustc_middle/src/mir/syntax.rs

@@ -886,6 +886,7 @@ pub enum AssertKind<O> {
     ResumedAfterReturn(CoroutineKind),
     ResumedAfterPanic(CoroutineKind),
     MisalignedPointerDereference { required: O, found: O },
+    OccupiedNiche { found: O, start: O, end: O, type_name: String, offset: O, niche_ty: String },
 }
 
 #[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, Hash, HashStable)]

compiler/rustc_middle/src/mir/terminator.rs

@@ -150,7 +150,7 @@ impl<O> AssertKind<O> {
             ResumedAfterReturn(CoroutineKind::Async(_)) => "`async fn` resumed after completion",
             ResumedAfterPanic(CoroutineKind::Coroutine) => "coroutine resumed after panicking",
             ResumedAfterPanic(CoroutineKind::Async(_)) => "`async fn` resumed after panicking",
-            BoundsCheck { .. } | MisalignedPointerDereference { .. } => {
+            BoundsCheck { .. } | MisalignedPointerDereference { .. } | OccupiedNiche { .. } => {
                 bug!("Unexpected AssertKind")
             }
         }
@@ -213,6 +213,13 @@ impl<O> AssertKind<O> {
                     "\"misaligned pointer dereference: address must be a multiple of {{}} but is {{}}\", {required:?}, {found:?}"
                 )
             }
+            OccupiedNiche { found, start, end, type_name, offset, niche_ty } => {
+                write!(
+                    f,
+                    "\"occupied niche: {{}} must be in {{}}..={{}} in a {{}} at offset {{}} with type {{}}\" {:?} {:?} {:?} {:?} {:?} {:?}",
+                    found, start, end, type_name, offset, niche_ty
+                )
+            }
             _ => write!(f, "\"{}\"", self.description()),
         }
     }
@@ -243,8 +250,8 @@ impl<O> AssertKind<O> {
             ResumedAfterPanic(CoroutineKind::Coroutine) => {
                 middle_assert_coroutine_resume_after_panic
             }
-
             MisalignedPointerDereference { .. } => middle_assert_misaligned_ptr_deref,
+            OccupiedNiche { .. } => middle_assert_occupied_niche,
         }
     }
 
@@ -281,6 +288,14 @@ impl<O> AssertKind<O> {
                 add!("required", format!("{required:#?}"));
                 add!("found", format!("{found:#?}"));
             }
+            OccupiedNiche { found, start, end, type_name, offset, niche_ty } => {
+                add!("found", format!("{found:?}"));
+                add!("start", format!("{start:?}"));
+                add!("end", format!("{end:?}"));
+                add!("type_name", format!("{type_name}"));
+                add!("offset", format!("{offset:?}"));
+                add!("niche_ty", format!("{niche_ty}"));
+            }
         }
     }
 }

compiler/rustc_middle/src/mir/visit.rs

@@ -625,6 +625,12 @@ macro_rules! make_mir_visitor {
                         self.visit_operand(required, location);
                         self.visit_operand(found, location);
                     }
+                    OccupiedNiche { found, start, end, type_name: _, offset, niche_ty: _ } => {
+                        self.visit_operand(found, location);
+                        self.visit_operand(start, location);
+                        self.visit_operand(end, location);
+                        self.visit_operand(offset, location);
+                    }
                 }
             }