Use a new NullOp and add back checks for slices and copy

saethlin · saethlin · commit 8e2596555b12 · 2024-02-04T20:42:46.000-05:00
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -1971,6 +1971,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                     ConstraintCategory::SizedBound,
                 );
             }
+            &Rvalue::NullaryOp(NullOp::DebugAssertions, _) => {}
 
             Rvalue::ShallowInitBox(operand, ty) => {
                 self.check_operand(operand, location);
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -767,6 +767,15 @@ fn codegen_stmt<'tcx>(
                         NullOp::OffsetOf(fields) => {
                             layout.offset_of_subfield(fx, fields.iter()).bytes()
                         }
+                        NullOp::DebugAssertions => {
+                            let val = fx.tcx.sess.opts.debug_assertions;
+                            let val = CValue::by_val(
+                                fx.bcx.ins().iconst(types::I8, i64::try_from(val).unwrap()),
+                                fx.layout_of(fx.tcx.types.bool),
+                            );
+                            lval.write_cvalue(fx, val);
+                            return;
+                        }
                     };
                     let val = CValue::by_val(
                         fx.bcx.ins().iconst(fx.pointer_type, i64::try_from(val).unwrap()),
diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
@@ -438,14 +438,6 @@ fn codegen_regular_intrinsic_call<'tcx>(
             fx.bcx.ins().trap(TrapCode::User(0));
             return;
         }
-        sym::debug_assertions => {
-            let bool_layout = fx.layout_of(fx.tcx.types.bool);
-            let val = CValue::by_val(
-                fx.bcx.ins().iconst(types::I8, fx.tcx.sess.opts.debug_assertions as i64),
-                bool_layout,
-            );
-            ret.write_cvalue(fx, val);
-        }
         sym::likely | sym::unlikely => {
             intrinsic_args!(fx, args => (a); intrinsic);
 
diff --git a/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs b/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs
@@ -84,7 +84,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 return;
             }
 
-            sym::debug_assertions => bx.const_bool(bx.tcx().sess.opts.debug_assertions),
             sym::va_start => bx.va_start(args[0].immediate()),
             sym::va_end => bx.va_end(args[0].immediate()),
             sym::size_of_val => {
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -672,17 +672,23 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let val = match null_op {
                     mir::NullOp::SizeOf => {
                         assert!(bx.cx().type_is_sized(ty));
-                        layout.size.bytes()
+                        let val = layout.size.bytes();
+                        bx.cx().const_usize(val)
                     }
                     mir::NullOp::AlignOf => {
                         assert!(bx.cx().type_is_sized(ty));
-                        layout.align.abi.bytes()
+                        let val = layout.align.abi.bytes();
+                        bx.cx().const_usize(val)
                     }
                     mir::NullOp::OffsetOf(fields) => {
-                        layout.offset_of_subfield(bx.cx(), fields.iter()).bytes()
+                        let val = layout.offset_of_subfield(bx.cx(), fields.iter()).bytes();
+                        bx.cx().const_usize(val)
+                    }
+                    mir::NullOp::DebugAssertions => {
+                        let val = bx.tcx().sess.opts.debug_assertions;
+                        bx.cx().const_bool(val)
                     }
                 };
-                let val = bx.cx().const_usize(val);
                 let tcx = self.cx.tcx();
                 OperandRef {
                     val: OperandValue::Immediate(val),
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -537,10 +537,6 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
             // not the optimization stage.)
             sym::is_val_statically_known => ecx.write_scalar(Scalar::from_bool(false), dest)?,
 
-            sym::debug_assertions => {
-                ecx.write_scalar(Scalar::from_bool(ecx.tcx.sess.opts.debug_assertions), dest)?
-            }
-
             _ => {
                 throw_unsup_format!(
                     "intrinsic `{intrinsic_name}` is not supported at compile-time"
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -246,13 +246,28 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                     );
                 }
                 let val = match null_op {
-                    mir::NullOp::SizeOf => layout.size.bytes(),
-                    mir::NullOp::AlignOf => layout.align.abi.bytes(),
+                    mir::NullOp::SizeOf => {
+                        let val = layout.size.bytes();
+                        Scalar::from_target_usize(val, self)
+                    }
+                    mir::NullOp::AlignOf => {
+                        let val = layout.align.abi.bytes();
+                        Scalar::from_target_usize(val, self)
+                    }
                     mir::NullOp::OffsetOf(fields) => {
-                        layout.offset_of_subfield(self, fields.iter()).bytes()
+                        let val = layout.offset_of_subfield(self, fields.iter()).bytes();
+                        Scalar::from_target_usize(val, self)
+                    }
+                    mir::NullOp::DebugAssertions => {
+                        // This should never actually lead us to any checks, because for the most
+                        // part those checks cannot be done in const-eval, and where they can be
+                        // done CTFE/Miri have better diagnostics.
+                        // But we implement the NullOp here to be correct I guess?
+                        let val = self.tcx.sess.opts.debug_assertions;
+                        Scalar::from_bool(val)
                     }
                 };
-                self.write_scalar(Scalar::from_target_usize(val, self), &dest)?;
+                self.write_scalar(val, &dest)?;
             }
 
             ShallowInitBox(ref operand, _) => {
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/check.rs b/compiler/rustc_const_eval/src/transform/check_consts/check.rs
@@ -571,7 +571,10 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
 
             Rvalue::Cast(_, _, _) => {}
 
-            Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(_), _) => {}
+            Rvalue::NullaryOp(
+                NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(_) | NullOp::DebugAssertions,
+                _,
+            ) => {}
             Rvalue::ShallowInitBox(_, _) => {}
 
             Rvalue::UnaryOp(_, operand) => {
diff --git a/compiler/rustc_const_eval/src/transform/validate.rs b/compiler/rustc_const_eval/src/transform/validate.rs
@@ -1116,7 +1116,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
             Rvalue::Repeat(_, _)
             | Rvalue::ThreadLocalRef(_)
             | Rvalue::AddressOf(_, _)
-            | Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf, _)
+            | Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::DebugAssertions, _)
             | Rvalue::Discriminant(_) => {}
         }
         self.super_rvalue(rvalue, location);
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
@@ -907,6 +907,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
                     NullOp::SizeOf => write!(fmt, "SizeOf({t})"),
                     NullOp::AlignOf => write!(fmt, "AlignOf({t})"),
                     NullOp::OffsetOf(fields) => write!(fmt, "OffsetOf({t}, {fields:?})"),
+                    NullOp::DebugAssertions => write!(fmt, "cfg!(debug_assertions)"),
                 }
             }
             ThreadLocalRef(did) => ty::tls::with(|tcx| {
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
@@ -1360,6 +1360,8 @@ pub enum NullOp<'tcx> {
     AlignOf,
     /// Returns the offset of a field
     OffsetOf(&'tcx List<(VariantIdx, FieldIdx)>),
+    /// cfg!(debug_assertions), but expanded in codegen
+    DebugAssertions,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
diff --git a/compiler/rustc_middle/src/mir/tcx.rs b/compiler/rustc_middle/src/mir/tcx.rs
@@ -194,6 +194,7 @@ impl<'tcx> Rvalue<'tcx> {
             Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(..), _) => {
                 tcx.types.usize
             }
+            Rvalue::NullaryOp(NullOp::DebugAssertions, _) => tcx.types.bool,
             Rvalue::Aggregate(ref ak, ref ops) => match **ak {
                 AggregateKind::Array(ty) => Ty::new_array(tcx, ty, ops.len() as u64),
                 AggregateKind::Tuple => {
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -425,7 +425,10 @@ impl<'b, 'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> Gatherer<'b, 'a, 'tcx, F> {
             | Rvalue::AddressOf(..)
             | Rvalue::Discriminant(..)
             | Rvalue::Len(..)
-            | Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(..), _) => {}
+            | Rvalue::NullaryOp(
+                NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(..) | NullOp::DebugAssertions,
+                _,
+            ) => {}
         }
     }
 
diff --git a/compiler/rustc_mir_transform/src/const_prop_lint.rs b/compiler/rustc_mir_transform/src/const_prop_lint.rs
@@ -638,6 +638,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
                     NullOp::OffsetOf(fields) => {
                         op_layout.offset_of_subfield(self, fields.iter()).bytes()
                     }
+                    NullOp::DebugAssertions => return None,
                 };
                 ImmTy::from_scalar(Scalar::from_target_usize(val, self), layout).into()
             }
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
@@ -489,6 +489,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     NullOp::OffsetOf(fields) => {
                         layout.offset_of_subfield(&self.ecx, fields.iter()).bytes()
                     }
+                    NullOp::DebugAssertions => return None,
                 };
                 let usize_layout = self.ecx.layout_of(self.tcx.types.usize).unwrap();
                 let imm = ImmTy::try_from_uint(val, usize_layout)?;
diff --git a/compiler/rustc_mir_transform/src/lower_intrinsics.rs b/compiler/rustc_mir_transform/src/lower_intrinsics.rs
@@ -21,6 +21,17 @@ impl<'tcx> MirPass<'tcx> for LowerIntrinsics {
                     sym::unreachable => {
                         terminator.kind = TerminatorKind::Unreachable;
                     }
+                    sym::debug_assertions => {
+                        let target = target.unwrap();
+                        block.statements.push(Statement {
+                            source_info: terminator.source_info,
+                            kind: StatementKind::Assign(Box::new((
+                                *destination,
+                                Rvalue::NullaryOp(NullOp::DebugAssertions, tcx.types.bool),
+                            ))),
+                        });
+                        terminator.kind = TerminatorKind::Goto { target };
+                    }
                     sym::forget => {
                         if let Some(target) = *target {
                             block.statements.push(Statement {
diff --git a/compiler/rustc_mir_transform/src/promote_consts.rs b/compiler/rustc_mir_transform/src/promote_consts.rs
@@ -446,6 +446,7 @@ impl<'tcx> Validator<'_, 'tcx> {
                 NullOp::SizeOf => {}
                 NullOp::AlignOf => {}
                 NullOp::OffsetOf(_) => {}
+                NullOp::DebugAssertions => {}
             },
 
             Rvalue::ShallowInitBox(_, _) => return Err(Unpromotable),
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/mir.rs b/compiler/rustc_smir/src/rustc_smir/convert/mir.rs
@@ -257,6 +257,7 @@ impl<'tcx> Stable<'tcx> for mir::NullOp<'tcx> {
             OffsetOf(indices) => stable_mir::mir::NullOp::OffsetOf(
                 indices.iter().map(|idx| idx.stable(tables)).collect(),
             ),
+            DebugAssertions => stable_mir::mir::NullOp::DebugAssertions,
         }
     }
 }
diff --git a/compiler/stable_mir/src/mir/body.rs b/compiler/stable_mir/src/mir/body.rs
@@ -639,6 +639,7 @@ impl Rvalue {
             Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(..), _) => {
                 Ok(Ty::usize_ty())
             }
+            Rvalue::NullaryOp(NullOp::DebugAssertions, _) => Ok(Ty::bool_ty()),
             Rvalue::Aggregate(ak, ops) => match *ak {
                 AggregateKind::Array(ty) => Ty::try_new_array(ty, ops.len() as u64),
                 AggregateKind::Tuple => Ok(Ty::new_tuple(
@@ -1005,6 +1006,8 @@ pub enum NullOp {
     AlignOf,
     /// Returns the offset of a field.
     OffsetOf(Vec<(VariantIdx, FieldIdx)>),
+    /// cfg!(debug_assertions), but at codegen time
+    DebugAssertions,
 }
 
 impl Operand {
diff --git a/library/core/src/intrinsics.rs b/library/core/src/intrinsics.rs
diff --git a/library/core/src/slice/raw.rs b/library/core/src/slice/raw.rs
diff --git a/src/tools/miri/src/shims/intrinsics/mod.rs b/src/tools/miri/src/shims/intrinsics/mod.rs
diff --git a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-abort.diff b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-abort.diff
diff --git a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-unwind.diff b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-unwind.diff
diff --git a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-abort.mir b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-abort.mir
diff --git a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-unwind.mir
diff --git a/tests/mir-opt/pre-codegen/duplicate_switch_targets.ub_if_b.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/duplicate_switch_targets.ub_if_b.PreCodegen.after.mir

Original file line number	Diff line number	Diff line change
`@@ -1971,6 +1971,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {`
`1971`	`1971`	`ConstraintCategory::SizedBound,`
`1972`	`1972`	`);`
`1973`	`1973`	`}`
	`1974`	`+ &Rvalue::NullaryOp(NullOp::DebugAssertions, _) => {}`
`1974`	`1975`
`1975`	`1976`	`Rvalue::ShallowInitBox(operand, ty) => {`
`1976`	`1977`	`self.check_operand(operand, location);`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {`
`84`	`84`	`return;`
`85`	`85`	`}`
`86`	`86`
`87`		`- sym::debug_assertions => bx.const_bool(bx.tcx().sess.opts.debug_assertions),`
`88`	`87`	`sym::va_start => bx.va_start(args[0].immediate()),`
`89`	`88`	`sym::va_end => bx.va_end(args[0].immediate()),`
`90`	`89`	`sym::size_of_val => {`
Original file line number	Diff line number	Diff line change
`@@ -1116,7 +1116,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {`
`1116`	`1116`	`Rvalue::Repeat(_, _)`
`1117`	`1117`	`\| Rvalue::ThreadLocalRef(_)`
`1118`	`1118`	`\| Rvalue::AddressOf(_, _)`
`1119`		`- \| Rvalue::NullaryOp(NullOp::SizeOf \| NullOp::AlignOf, _)`
	`1119`	`+ \| Rvalue::NullaryOp(NullOp::SizeOf \| NullOp::AlignOf \| NullOp::DebugAssertions, _)`
`1120`	`1120`	`\| Rvalue::Discriminant(_) => {}`
`1121`	`1121`	`}`
`1122`	`1122`	`self.super_rvalue(rvalue, location);`
Original file line number	Diff line number	Diff line change
`@@ -907,6 +907,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {`
`907`	`907`	`NullOp::SizeOf => write!(fmt, "SizeOf({t})"),`
`908`	`908`	`NullOp::AlignOf => write!(fmt, "AlignOf({t})"),`
`909`	`909`	`NullOp::OffsetOf(fields) => write!(fmt, "OffsetOf({t}, {fields:?})"),`
	`910`	`+ NullOp::DebugAssertions => write!(fmt, "cfg!(debug_assertions)"),`
`910`	`911`	`}`
`911`	`912`	`}`
`912`	`913`	`ThreadLocalRef(did) => ty::tls::with(\|tcx\| {`
Original file line number	Diff line number	Diff line change
`@@ -1360,6 +1360,8 @@ pub enum NullOp<'tcx> {`
`1360`	`1360`	`AlignOf,`
`1361`	`1361`	`/// Returns the offset of a field`
`1362`	`1362`	`OffsetOf(&'tcx List<(VariantIdx, FieldIdx)>),`
	`1363`	`+ /// cfg!(debug_assertions), but expanded in codegen`
	`1364`	`+ DebugAssertions,`
`1363`	`1365`	`}`
`1364`	`1366`
`1365`	`1367`	`#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]`
Original file line number	Diff line number	Diff line change
`@@ -194,6 +194,7 @@ impl<'tcx> Rvalue<'tcx> {`
`194`	`194`	`Rvalue::NullaryOp(NullOp::SizeOf \| NullOp::AlignOf \| NullOp::OffsetOf(..), _) => {`
`195`	`195`	`tcx.types.usize`
`196`	`196`	`}`
	`197`	`+ Rvalue::NullaryOp(NullOp::DebugAssertions, _) => tcx.types.bool,`
`197`	`198`	`Rvalue::Aggregate(ref ak, ref ops) => match **ak {`
`198`	`199`	`AggregateKind::Array(ty) => Ty::new_array(tcx, ty, ops.len() as u64),`
`199`	`200`	`AggregateKind::Tuple => {`
Original file line number	Diff line number	Diff line change
`@@ -425,7 +425,10 @@ impl<'b, 'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> Gatherer<'b, 'a, 'tcx, F> {`
`425`	`425`	`\| Rvalue::AddressOf(..)`
`426`	`426`	`\| Rvalue::Discriminant(..)`
`427`	`427`	`\| Rvalue::Len(..)`
`428`		`- \| Rvalue::NullaryOp(NullOp::SizeOf \| NullOp::AlignOf \| NullOp::OffsetOf(..), _) => {}`
	`428`	`+ \| Rvalue::NullaryOp(`
	`429`	`+ NullOp::SizeOf \| NullOp::AlignOf \| NullOp::OffsetOf(..) \| NullOp::DebugAssertions,`
	`430`	`+ _,`
	`431`	`+ ) => {}`
`429`	`432`	`}`
`430`	`433`	`}`
`431`	`434`
Original file line number	Diff line number	Diff line change
`@@ -638,6 +638,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {`
`638`	`638`	`NullOp::OffsetOf(fields) => {`
`639`	`639`	`op_layout.offset_of_subfield(self, fields.iter()).bytes()`
`640`	`640`	`}`
	`641`	`+ NullOp::DebugAssertions => return None,`
`641`	`642`	`};`
`642`	`643`	`ImmTy::from_scalar(Scalar::from_target_usize(val, self), layout).into()`
`643`	`644`	`}`
Original file line number	Diff line number	Diff line change
`@@ -489,6 +489,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {`
`489`	`489`	`NullOp::OffsetOf(fields) => {`
`490`	`490`	`layout.offset_of_subfield(&self.ecx, fields.iter()).bytes()`
`491`	`491`	`}`
	`492`	`+ NullOp::DebugAssertions => return None,`
`492`	`493`	`};`
`493`	`494`	`let usize_layout = self.ecx.layout_of(self.tcx.types.usize).unwrap();`
`494`	`495`	`let imm = ImmTy::try_from_uint(val, usize_layout)?;`
Original file line number	Diff line number	Diff line change
`@@ -257,6 +257,7 @@ impl<'tcx> Stable<'tcx> for mir::NullOp<'tcx> {`
`257`	`257`	`OffsetOf(indices) => stable_mir::mir::NullOp::OffsetOf(`
`258`	`258`	`indices.iter().map(\|idx\| idx.stable(tables)).collect(),`
`259`	`259`	`),`
	`260`	`+ DebugAssertions => stable_mir::mir::NullOp::DebugAssertions,`
`260`	`261`	`}`
`261`	`262`	`}`
`262`	`263`	`}`