mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

const: don't ICE when encountering a mutable ref to immutable memory

Browse Source
This commit is contained in:
Ralf Jung 2024-09-15 13:11:05 +02:00
parent 8c2c9a9ef5
commit 7dfffe7e70
6 changed files with 37 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
compiler/rustc_const_eval/src/interpret/validity.rs
View File

@ -14,6 +14,7 @@
use rustc_ast::Mutability; use rustc_ast::Mutability;
use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::fx::FxHashSet;
use rustc_hir as hir; use rustc_hir as hir;
use rustc_middle::bug;
use rustc_middle::mir::interpret::ValidationErrorKind::{self, *}; use rustc_middle::mir::interpret::ValidationErrorKind::{self, *};
use rustc_middle::mir::interpret::{ use rustc_middle::mir::interpret::{
alloc_range, ExpectedKind, InterpError, InvalidMetaKind, Misalignment, PointerKind, Provenance, alloc_range, ExpectedKind, InterpError, InvalidMetaKind, Misalignment, PointerKind, Provenance,
@ -21,7 +22,6 @@
}; };
use rustc_middle::ty::layout::{LayoutCx, LayoutOf, TyAndLayout}; use rustc_middle::ty::layout::{LayoutCx, LayoutOf, TyAndLayout};
use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_middle::{bug, span_bug};
use rustc_span::symbol::{sym, Symbol}; use rustc_span::symbol::{sym, Symbol};
use rustc_target::abi::{ use rustc_target::abi::{
Abi, FieldIdx, FieldsShape, Scalar as ScalarAbi, Size, VariantIdx, Variants, WrappingRange, Abi, FieldIdx, FieldsShape, Scalar as ScalarAbi, Size, VariantIdx, Variants, WrappingRange,
@ -617,13 +617,7 @@ fn check_safe_pointer(
if ptr_expected_mutbl == Mutability::Mut if ptr_expected_mutbl == Mutability::Mut
&& alloc_actual_mutbl == Mutability::Not && alloc_actual_mutbl == Mutability::Not
{ {
if !self.ecx.tcx.sess.opts.unstable_opts.unleash_the_miri_inside_of_you // This can actually occur with transmutes.
{
span_bug!(
self.ecx.tcx.span,
"the static const safety checks accepted mutable references they should not have accepted"
);
}
throw_validation_failure!(self.path, MutableRefToImmutable); throw_validation_failure!(self.path, MutableRefToImmutable);
} }
// In a const, everything must be completely immutable. // In a const, everything must be completely immutable.

14
tests/ui/consts/const-eval/transmute-const.64bit.stderr
View File

@ -1,14 +0,0 @@
error[E0080]: it is undefined behavior to use this value
--> $DIR/transmute-const.rs:4:1
|
LL | static FOO: bool = unsafe { mem::transmute(3u8) };
| ^^^^^^^^^^^^^^^^ constructing invalid value: encountered 0x03, but expected a boolean
|
= 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.
= note: the raw bytes of the constant (size: 1, align: 1) {
03 │ .
}
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0080`.

1
tests/ui/consts/const-eval/transmute-const.rs
View File

@ -1,4 +1,3 @@
//@ stderr-per-bitwidth
use std::mem; use std::mem;
static FOO: bool = unsafe { mem::transmute(3u8) }; static FOO: bool = unsafe { mem::transmute(3u8) };

2
tests/ui/consts/const-eval/transmute-const.32bit.stderr → tests/ui/consts/const-eval/transmute-const.stderr
View File

@ -1,5 +1,5 @@
error[E0080]: it is undefined behavior to use this value error[E0080]: it is undefined behavior to use this value
--> $DIR/transmute-const.rs:4:1 --> $DIR/transmute-const.rs:3:1
| |
LL | static FOO: bool = unsafe { mem::transmute(3u8) }; LL | static FOO: bool = unsafe { mem::transmute(3u8) };
| ^^^^^^^^^^^^^^^^ constructing invalid value: encountered 0x03, but expected a boolean | ^^^^^^^^^^^^^^^^ constructing invalid value: encountered 0x03, but expected a boolean

10
tests/ui/consts/const-mut-refs/mut_ref_in_final.rs
View File

@ -1,4 +1,9 @@
//@ normalize-stderr-test: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
//@ normalize-stderr-test: "( 0x[0-9a-f][0-9a-f] │)? ([0-9a-f][0-9a-f] |__ |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> " HEX_DUMP"
//@ normalize-stderr-test: "HEX_DUMP\s*\n\s*HEX_DUMP" -> "HEX_DUMP"
use std::cell::UnsafeCell; use std::cell::UnsafeCell;
use std::mem;
const NULL: *mut i32 = std::ptr::null_mut(); const NULL: *mut i32 = std::ptr::null_mut();
const A: *const i32 = &4; const A: *const i32 = &4;
@ -17,6 +22,11 @@
const fn helper(x: &mut i32) -> Option<&mut i32> { Some(x) } const fn helper(x: &mut i32) -> Option<&mut i32> { Some(x) }
const B4: Option<&mut i32> = helper(&mut 42); //~ ERROR temporary value dropped while borrowed const B4: Option<&mut i32> = helper(&mut 42); //~ ERROR temporary value dropped while borrowed
// Not ok, since it points to read-only memory.
const IMMUT_MUT_REF: &mut u16 = unsafe { mem::transmute(&13) };
//~^ ERROR undefined behavior to use this value
//~| pointing to read-only memory
// Ok, because no references to mutable data exist here, since the `{}` moves // Ok, because no references to mutable data exist here, since the `{}` moves
// its value and then takes a reference to that. // its value and then takes a reference to that.
const C: *const i32 = &{ const C: *const i32 = &{

37
tests/ui/consts/const-mut-refs/mut_ref_in_final.stderr
View File

@ -1,11 +1,11 @@
error[E0764]: mutable references are not allowed in the final value of constants error[E0764]: mutable references are not allowed in the final value of constants
--> $DIR/mut_ref_in_final.rs:9:21 --> $DIR/mut_ref_in_final.rs:14:21
| |
LL | const B: *mut i32 = &mut 4; LL | const B: *mut i32 = &mut 4;
| ^^^^^^ | ^^^^^^
error[E0716]: temporary value dropped while borrowed error[E0716]: temporary value dropped while borrowed
--> $DIR/mut_ref_in_final.rs:15:40 --> $DIR/mut_ref_in_final.rs:20:40
| |
LL | const B3: Option<&mut i32> = Some(&mut 42); LL | const B3: Option<&mut i32> = Some(&mut 42);
| ----------^^- | ----------^^-
@ -15,7 +15,7 @@ LL | const B3: Option<&mut i32> = Some(&mut 42);
| using this value as a constant requires that borrow lasts for `'static` | using this value as a constant requires that borrow lasts for `'static`
error[E0716]: temporary value dropped while borrowed error[E0716]: temporary value dropped while borrowed
--> $DIR/mut_ref_in_final.rs:18:42 --> $DIR/mut_ref_in_final.rs:23:42
| |
LL | const B4: Option<&mut i32> = helper(&mut 42); LL | const B4: Option<&mut i32> = helper(&mut 42);
| ------------^^- | ------------^^-
@ -24,8 +24,19 @@ LL | const B4: Option<&mut i32> = helper(&mut 42);
| | creates a temporary value which is freed while still in use | | creates a temporary value which is freed while still in use
| using this value as a constant requires that borrow lasts for `'static` | using this value as a constant requires that borrow lasts for `'static`
error[E0080]: it is undefined behavior to use this value
--> $DIR/mut_ref_in_final.rs:26:1
|
LL | const IMMUT_MUT_REF: &mut u16 = unsafe { mem::transmute(&13) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value: encountered mutable reference or box pointing to read-only memory
|
= 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.
= note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
HEX_DUMP
}
error[E0716]: temporary value dropped while borrowed error[E0716]: temporary value dropped while borrowed
--> $DIR/mut_ref_in_final.rs:40:65 --> $DIR/mut_ref_in_final.rs:50:65
| |
LL | const FOO: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42)); LL | const FOO: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
| -------------------------------^^-- | -------------------------------^^--
@ -35,7 +46,7 @@ LL | const FOO: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
| using this value as a constant requires that borrow lasts for `'static` | using this value as a constant requires that borrow lasts for `'static`
error[E0716]: temporary value dropped while borrowed error[E0716]: temporary value dropped while borrowed
--> $DIR/mut_ref_in_final.rs:43:67 --> $DIR/mut_ref_in_final.rs:53:67
| |
LL | static FOO2: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42)); LL | static FOO2: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
| -------------------------------^^-- | -------------------------------^^--
@ -45,7 +56,7 @@ LL | static FOO2: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
| using this value as a static requires that borrow lasts for `'static` | using this value as a static requires that borrow lasts for `'static`
error[E0716]: temporary value dropped while borrowed error[E0716]: temporary value dropped while borrowed
--> $DIR/mut_ref_in_final.rs:46:71 --> $DIR/mut_ref_in_final.rs:56:71
| |
LL | static mut FOO3: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42)); LL | static mut FOO3: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
| -------------------------------^^-- | -------------------------------^^--
@ -55,30 +66,30 @@ LL | static mut FOO3: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
| using this value as a static requires that borrow lasts for `'static` | using this value as a static requires that borrow lasts for `'static`
error[E0764]: mutable references are not allowed in the final value of statics error[E0764]: mutable references are not allowed in the final value of statics
--> $DIR/mut_ref_in_final.rs:59:53 --> $DIR/mut_ref_in_final.rs:69:53
| |
LL | static RAW_MUT_CAST_S: SyncPtr<i32> = SyncPtr { x : &mut 42 as *mut _ as *const _ }; LL | static RAW_MUT_CAST_S: SyncPtr<i32> = SyncPtr { x : &mut 42 as *mut _ as *const _ };
| ^^^^^^^ | ^^^^^^^
error[E0764]: mutable references are not allowed in the final value of statics error[E0764]: mutable references are not allowed in the final value of statics
--> $DIR/mut_ref_in_final.rs:61:54 --> $DIR/mut_ref_in_final.rs:71:54
| |
LL | static RAW_MUT_COERCE_S: SyncPtr<i32> = SyncPtr { x: &mut 0 }; LL | static RAW_MUT_COERCE_S: SyncPtr<i32> = SyncPtr { x: &mut 0 };
| ^^^^^^ | ^^^^^^
error[E0764]: mutable references are not allowed in the final value of constants error[E0764]: mutable references are not allowed in the final value of constants
--> $DIR/mut_ref_in_final.rs:63:52 --> $DIR/mut_ref_in_final.rs:73:52
| |
LL | const RAW_MUT_CAST_C: SyncPtr<i32> = SyncPtr { x : &mut 42 as *mut _ as *const _ }; LL | const RAW_MUT_CAST_C: SyncPtr<i32> = SyncPtr { x : &mut 42 as *mut _ as *const _ };
| ^^^^^^^ | ^^^^^^^
error[E0764]: mutable references are not allowed in the final value of constants error[E0764]: mutable references are not allowed in the final value of constants
--> $DIR/mut_ref_in_final.rs:65:53 --> $DIR/mut_ref_in_final.rs:75:53
| |
LL | const RAW_MUT_COERCE_C: SyncPtr<i32> = SyncPtr { x: &mut 0 }; LL | const RAW_MUT_COERCE_C: SyncPtr<i32> = SyncPtr { x: &mut 0 };
| ^^^^^^ | ^^^^^^
error: aborting due to 10 previous errors error: aborting due to 11 previous errors
Some errors have detailed explanations: E0716, E0764. Some errors have detailed explanations: E0080, E0716, E0764.
For more information about an error, try `rustc --explain E0716`. For more information about an error, try `rustc --explain E0080`.