Skip to content

Commit 9ab5051

Browse files
RalfJungRalfJung
committed
allow mutable references in const values when they point to no memory
1 parent 0f806a9 commit 9ab5051

File tree

7 files changed

+97
-80
lines changed

7 files changed

+97
-80
lines changed

‎compiler/rustc_const_eval/src/errors.rs

Lines changed: 11 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -603,12 +603,12 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
603603
PtrToUninhabited { ptr_kind: PointerKind::Box, .. } => {
604604
const_eval_validation_box_to_uninhabited
605605
}
606-
PtrToUninhabited { ptr_kind: PointerKind::Ref, .. } => {
606+
PtrToUninhabited { ptr_kind: PointerKind::Ref(_), .. } => {
607607
const_eval_validation_ref_to_uninhabited
608608
}
609609

610610
PtrToStatic { ptr_kind: PointerKind::Box } => const_eval_validation_box_to_static,
611-
PtrToStatic { ptr_kind: PointerKind::Ref } => const_eval_validation_ref_to_static,
611+
PtrToStatic { ptr_kind: PointerKind::Ref(_) } => const_eval_validation_ref_to_static,
612612

613613
PointerAsInt { .. } => const_eval_validation_pointer_as_int,
614614
PartialPointer => const_eval_validation_partial_pointer,
@@ -630,37 +630,39 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
630630
InvalidMetaSliceTooLarge { ptr_kind: PointerKind::Box } => {
631631
const_eval_validation_invalid_box_slice_meta
632632
}
633-
InvalidMetaSliceTooLarge { ptr_kind: PointerKind::Ref } => {
633+
InvalidMetaSliceTooLarge { ptr_kind: PointerKind::Ref(_) } => {
634634
const_eval_validation_invalid_ref_slice_meta
635635
}
636636

637637
InvalidMetaTooLarge { ptr_kind: PointerKind::Box } => {
638638
const_eval_validation_invalid_box_meta
639639
}
640-
InvalidMetaTooLarge { ptr_kind: PointerKind::Ref } => {
640+
InvalidMetaTooLarge { ptr_kind: PointerKind::Ref(_) } => {
641641
const_eval_validation_invalid_ref_meta
642642
}
643-
UnalignedPtr { ptr_kind: PointerKind::Ref, .. } => const_eval_validation_unaligned_ref,
643+
UnalignedPtr { ptr_kind: PointerKind::Ref(_), .. } => {
644+
const_eval_validation_unaligned_ref
645+
}
644646
UnalignedPtr { ptr_kind: PointerKind::Box, .. } => const_eval_validation_unaligned_box,
645647

646648
NullPtr { ptr_kind: PointerKind::Box } => const_eval_validation_null_box,
647-
NullPtr { ptr_kind: PointerKind::Ref } => const_eval_validation_null_ref,
649+
NullPtr { ptr_kind: PointerKind::Ref(_) } => const_eval_validation_null_ref,
648650
DanglingPtrNoProvenance { ptr_kind: PointerKind::Box, .. } => {
649651
const_eval_validation_dangling_box_no_provenance
650652
}
651-
DanglingPtrNoProvenance { ptr_kind: PointerKind::Ref, .. } => {
653+
DanglingPtrNoProvenance { ptr_kind: PointerKind::Ref(_), .. } => {
652654
const_eval_validation_dangling_ref_no_provenance
653655
}
654656
DanglingPtrOutOfBounds { ptr_kind: PointerKind::Box } => {
655657
const_eval_validation_dangling_box_out_of_bounds
656658
}
657-
DanglingPtrOutOfBounds { ptr_kind: PointerKind::Ref } => {
659+
DanglingPtrOutOfBounds { ptr_kind: PointerKind::Ref(_) } => {
658660
const_eval_validation_dangling_ref_out_of_bounds
659661
}
660662
DanglingPtrUseAfterFree { ptr_kind: PointerKind::Box } => {
661663
const_eval_validation_dangling_box_use_after_free
662664
}
663-
DanglingPtrUseAfterFree { ptr_kind: PointerKind::Ref } => {
665+
DanglingPtrUseAfterFree { ptr_kind: PointerKind::Ref(_) } => {
664666
const_eval_validation_dangling_ref_use_after_free
665667
}
666668
InvalidBool { .. } => const_eval_validation_invalid_bool,

‎compiler/rustc_const_eval/src/interpret/validity.rs

Lines changed: 47 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -156,6 +156,14 @@ impl CtfeValidationMode {
156156
CtfeValidationMode::Const { .. } => false,
157157
}
158158
}
159+
160+
fn may_point_to_mutable(self) -> bool {
161+
match self {
162+
CtfeValidationMode::Const { .. } => false,
163+
CtfeValidationMode::Static { .. } => true,
164+
CtfeValidationMode::Promoted { .. } => true,
165+
}
166+
}
159167
}
160168

161169
/// State for tracking recursive validation of references
@@ -445,22 +453,22 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
445453
// Determine whether this pointer expects to be pointing to something mutable.
446454
let ptr_expected_mutbl = match ptr_kind {
447455
PointerKind::Box => Mutability::Mut,
448-
PointerKind::Ref => {
449-
let tam = value.layout.ty.builtin_deref(false).unwrap();
450-
// ZST never require mutability. We do not take into account interior mutability
451-
// here since we cannot know if there really is an `UnsafeCell` inside
452-
// `Option<UnsafeCell>` -- so we check that in the recursive descent behind this
453-
// reference.
454-
if size == Size::ZERO { Mutability::Not } else { tam.mutbl }
456+
PointerKind::Ref(mutbl) => {
457+
// We do not take into account interior mutability here since we cannot know if
458+
// there really is an `UnsafeCell` inside `Option<UnsafeCell>` -- so we check
459+
// that in the recursive descent behind this reference (controlled by
460+
// `allow_immutable_unsafe_cell`).
461+
mutbl
455462
}
456463
};
457464
// Proceed recursively even for ZST, no reason to skip them!
458465
// `!` is a ZST and we want to validate it.
459466
if let Ok((alloc_id, _offset, _prov)) = self.ecx.ptr_try_get_alloc_id(place.ptr()) {
467+
let mut skip_recursive_check = false;
460468
// Let's see what kind of memory this points to.
461469
// `unwrap` since dangling pointers have already been handled.
462470
let alloc_kind = self.ecx.tcx.try_get_global_alloc(alloc_id).unwrap();
463-
match alloc_kind {
471+
let alloc_actual_mutbl = match alloc_kind {
464472
GlobalAlloc::Static(did) => {
465473
// Special handling for pointers to statics (irrespective of their type).
466474
assert!(!self.ecx.tcx.is_thread_local_static(did));
@@ -474,12 +482,6 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
474482
.no_bound_vars()
475483
.expect("statics should not have generic parameters")
476484
.is_freeze(*self.ecx.tcx, ty::ParamEnv::reveal_all());
477-
// Mutability check.
478-
if ptr_expected_mutbl == Mutability::Mut {
479-
if !is_mut {
480-
throw_validation_failure!(self.path, MutableRefToImmutable);
481-
}
482-
}
483485
// Mode-specific checks
484486
match self.ctfe_mode {
485487
Some(
@@ -494,42 +496,49 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
494496
// trigger cycle errors if we try to compute the value of the other static
495497
// and that static refers back to us (potentially through a promoted).
496498
// This could miss some UB, but that's fine.
497-
return Ok(());
499+
skip_recursive_check = true;
498500
}
499501
Some(CtfeValidationMode::Const { .. }) => {
500-
// For consts on the other hand we have to recursively check;
501-
// pattern matching assumes a valid value. However we better make
502-
// sure this is not mutable.
503-
if is_mut {
504-
throw_validation_failure!(self.path, ConstRefToMutable);
505-
}
506502
// We can't recursively validate `extern static`, so we better reject them.
507503
if self.ecx.tcx.is_foreign_item(did) {
508504
throw_validation_failure!(self.path, ConstRefToExtern);
509505
}
510506
}
511507
None => {}
512508
}
509+
// Return alloc mutability
510+
if is_mut { Mutability::Mut } else { Mutability::Not }
513511
}
514-
GlobalAlloc::Memory(alloc) => {
515-
if alloc.inner().mutability == Mutability::Mut
516-
&& matches!(self.ctfe_mode, Some(CtfeValidationMode::Const { .. }))
517-
{
518-
throw_validation_failure!(self.path, ConstRefToMutable);
519-
}
520-
if ptr_expected_mutbl == Mutability::Mut
521-
&& alloc.inner().mutability == Mutability::Not
522-
{
523-
throw_validation_failure!(self.path, MutableRefToImmutable);
524-
}
525-
}
512+
GlobalAlloc::Memory(alloc) => alloc.inner().mutability,
526513
GlobalAlloc::Function(..) | GlobalAlloc::VTable(..) => {
527514
// These are immutable, we better don't allow mutable pointers here.
528-
if ptr_expected_mutbl == Mutability::Mut {
529-
throw_validation_failure!(self.path, MutableRefToImmutable);
530-
}
515+
Mutability::Not
516+
}
517+
};
518+
// Mutability check.
519+
// If this allocation has size zero, there is no actual mutability here.
520+
let (size, _align, _alloc_kind) = self.ecx.get_alloc_info(alloc_id);
521+
if size != Size::ZERO {
522+
if ptr_expected_mutbl == Mutability::Mut
523+
&& alloc_actual_mutbl == Mutability::Not
524+
{
525+
throw_validation_failure!(self.path, MutableRefToImmutable);
526+
}
527+
if ptr_expected_mutbl == Mutability::Mut
528+
&& self.ctfe_mode.is_some_and(|c| !c.may_contain_mutable_ref())
529+
{
530+
throw_validation_failure!(self.path, MutableRefInConst);
531+
}
532+
if alloc_actual_mutbl == Mutability::Mut
533+
&& self.ctfe_mode.is_some_and(|c| !c.may_point_to_mutable())
534+
{
535+
throw_validation_failure!(self.path, ConstRefToMutable);
531536
}
532537
}
538+
// Potentially skip recursive check.
539+
if skip_recursive_check {
540+
return Ok(());
541+
}
533542
}
534543
let path = &self.path;
535544
ref_tracking.track(place, || {
@@ -598,16 +607,8 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
598607
}
599608
Ok(true)
600609
}
601-
ty::Ref(_, ty, mutbl) => {
602-
if self.ctfe_mode.is_some_and(|c| !c.may_contain_mutable_ref())
603-
&& *mutbl == Mutability::Mut
604-
{
605-
let layout = self.ecx.layout_of(*ty)?;
606-
if !layout.is_zst() {
607-
throw_validation_failure!(self.path, MutableRefInConst);
608-
}
609-
}
610-
self.check_safe_pointer(value, PointerKind::Ref)?;
610+
ty::Ref(_, _ty, mutbl) => {
611+
self.check_safe_pointer(value, PointerKind::Ref(*mutbl))?;
611612
Ok(true)
612613
}
613614
ty::FnPtr(_sig) => {

‎compiler/rustc_middle/src/mir/interpret/error.rs

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@ use rustc_macros::HashStable;
1212
use rustc_session::CtfeBacktrace;
1313
use rustc_span::{def_id::DefId, Span, DUMMY_SP};
1414
use rustc_target::abi::{call, Align, Size, VariantIdx, WrappingRange};
15+
use rustc_type_ir::Mutability;
1516

1617
use std::borrow::Cow;
1718
use std::{any::Any, backtrace::Backtrace, fmt};
@@ -367,15 +368,15 @@ pub enum UndefinedBehaviorInfo<'tcx> {
367368

368369
#[derive(Debug, Clone, Copy)]
369370
pub enum PointerKind {
370-
Ref,
371+
Ref(Mutability),
371372
Box,
372373
}
373374

374375
impl IntoDiagnosticArg for PointerKind {
375376
fn into_diagnostic_arg(self) -> DiagnosticArgValue {
376377
DiagnosticArgValue::Str(
377378
match self {
378-
Self::Ref => "ref",
379+
Self::Ref(_) => "ref",
379380
Self::Box => "box",
380381
}
381382
.into(),
@@ -408,7 +409,7 @@ impl From<PointerKind> for ExpectedKind {
408409
fn from(x: PointerKind) -> ExpectedKind {
409410
match x {
410411
PointerKind::Box => ExpectedKind::Box,
411-
PointerKind::Ref => ExpectedKind::Reference,
412+
PointerKind::Ref(_) => ExpectedKind::Reference,
412413
}
413414
}
414415
}

‎tests/ui/consts/const-mut-refs/const_mut_refs.rs

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,8 @@
11
// check-pass
22
#![feature(const_mut_refs)]
33

4+
use std::sync::Mutex;
5+
46
struct Foo {
57
x: usize
68
}
@@ -28,6 +30,10 @@ const fn bazz(foo: &mut Foo) -> usize {
2830
foo.x
2931
}
3032

33+
// Empty slices get promoted so this passes the static checks.
34+
// Make sure it also passes the dynamic checks.
35+
static MUTABLE_REFERENCE_HOLDER: Mutex<&mut [u8]> = Mutex::new(&mut []);
36+
3137
fn main() {
3238
let _: [(); foo().bar()] = [(); 1];
3339
let _: [(); baz(&mut foo())] = [(); 2];

‎tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.32bit.stderr

Lines changed: 11 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,19 +1,24 @@
11
error[E0080]: it is undefined behavior to use this value
2-
--> $DIR/mut_ref_in_final_dynamic_check.rs:15:1
2+
--> $DIR/mut_ref_in_final_dynamic_check.rs:16:1
33
|
44
LL | const A: Option<&mut i32> = helper();
55
| ^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<enum-variant(Some)>.0: encountered mutable reference in a `const` or `static`
66
|
77
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
88
= note: the raw bytes of the constant (size: 4, align: 4) {
9-
2a 00 00 00 │ *...
9+
╾ALLOC0╼ │ ╾──╼
1010
}
1111

12-
error: encountered dangling pointer in final value of constant
13-
--> $DIR/mut_ref_in_final_dynamic_check.rs:22:1
12+
error[E0080]: it is undefined behavior to use this value
13+
--> $DIR/mut_ref_in_final_dynamic_check.rs:18:1
14+
|
15+
LL | static A_STATIC: Option<&mut i32> = helper();
16+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<enum-variant(Some)>.0: encountered mutable reference in a `const` or `static`
1417
|
15-
LL | const B: Option<&mut i32> = helper2();
16-
| ^^^^^^^^^^^^^^^^^^^^^^^^^
18+
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
19+
= note: the raw bytes of the constant (size: 4, align: 4) {
20+
╾ALLOC0╼ │ ╾──╼
21+
}
1722

1823
error: aborting due to 2 previous errors
1924

‎tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.64bit.stderr

Lines changed: 11 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,19 +1,24 @@
11
error[E0080]: it is undefined behavior to use this value
2-
--> $DIR/mut_ref_in_final_dynamic_check.rs:15:1
2+
--> $DIR/mut_ref_in_final_dynamic_check.rs:16:1
33
|
44
LL | const A: Option<&mut i32> = helper();
55
| ^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<enum-variant(Some)>.0: encountered mutable reference in a `const` or `static`
66
|
77
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
88
= note: the raw bytes of the constant (size: 8, align: 8) {
9-
2a 00 00 00 00 00 00 00 │ *.......
9+
╾ALLOC0╼ │ ╾──────╼
1010
}
1111

12-
error: encountered dangling pointer in final value of constant
13-
--> $DIR/mut_ref_in_final_dynamic_check.rs:22:1
12+
error[E0080]: it is undefined behavior to use this value
13+
--> $DIR/mut_ref_in_final_dynamic_check.rs:18:1
14+
|
15+
LL | static A_STATIC: Option<&mut i32> = helper();
16+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<enum-variant(Some)>.0: encountered mutable reference in a `const` or `static`
1417
|
15-
LL | const B: Option<&mut i32> = helper2();
16-
| ^^^^^^^^^^^^^^^^^^^^^^^^^
18+
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
19+
= note: the raw bytes of the constant (size: 8, align: 8) {
20+
╾ALLOC0╼ │ ╾──────╼
21+
}
1722

1823
error: aborting due to 2 previous errors
1924

‎tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs

Lines changed: 7 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
// stderr-per-bitwidth
2-
#![feature(const_mut_refs)]
2+
#![feature(const_mut_refs, const_refs_to_static)]
33
#![feature(raw_ref_op)]
44

55
// This file checks that our dynamic checks catch things that the static checks miss.
@@ -8,17 +8,14 @@
88
// do that without causing the borrow checker to complain (see the B4/helper test in
99
// mut_ref_in_final.rs).
1010

11+
static mut BUFFER: i32 = 42;
12+
1113
const fn helper() -> Option<&'static mut i32> { unsafe {
12-
// Undefined behaviour (integer as pointer), who doesn't love tests like this.
13-
Some(&mut *(42 as *mut i32))
14+
Some(&mut *std::ptr::addr_of_mut!(BUFFER))
1415
} }
1516
const A: Option<&mut i32> = helper(); //~ ERROR it is undefined behavior to use this value
16-
//~^ encountered mutable reference in a `const`
17-
18-
const fn helper2() -> Option<&'static mut i32> { unsafe {
19-
// Undefined behaviour (dangling pointer), who doesn't love tests like this.
20-
Some(&mut *(&mut 42 as *mut i32))
21-
} }
22-
const B: Option<&mut i32> = helper2(); //~ ERROR encountered dangling pointer in final value of constant
17+
//~^ encountered mutable reference
18+
static A_STATIC: Option<&mut i32> = helper(); //~ ERROR it is undefined behavior to use this value
19+
//~^ encountered mutable reference
2320

2421
fn main() {}

0 commit comments

Comments
 (0)