In uninit checking, add fallback for polymorphic types

This commit is contained in:
Nilstrieb 2023-03-26 14:52:46 +00:00
parent 5ed64d4c61
commit 51b4d2a1e8
4 changed files with 47 additions and 11 deletions

View file

@ -541,9 +541,25 @@ pub fn same_type_and_consts<'tcx>(a: Ty<'tcx>, b: Ty<'tcx>) -> bool {
pub fn is_uninit_value_valid_for_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
cx.tcx
.check_validity_requirement((ValidityRequirement::Uninit, cx.param_env.and(ty)))
// For types containing generic parameters we cannot get a layout to check.
// Therefore, we are conservative and assume that they don't allow uninit.
.unwrap_or(false)
.unwrap_or_else(|_| is_uninit_value_valid_for_ty_fallback(cx, ty))
}
/// A fallback for polymorphic types, which are not supported by `check_validity_requirement`.
fn is_uninit_value_valid_for_ty_fallback<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
match *ty.kind() {
// The array length may be polymorphic, let's try the inner type.
ty::Array(component, _) => is_uninit_value_valid_for_ty(cx, component),
// Peek through tuples and try their fallbacks.
ty::Tuple(types) => types.iter().all(|ty| is_uninit_value_valid_for_ty(cx, ty)),
// Unions are always fine right now.
// This includes MaybeUninit, the main way people use uninitialized memory.
// For ADTs, we could look at all fields just like for tuples, but that's potentially
// exponential, so let's avoid doing that for now. Code doing that is sketchy enough to
// just use an `#[allow()]`.
ty::Adt(adt, _) => adt.is_union(),
// For the rest, conservatively assume that they cannot be uninit.
_ => false,
}
}
/// Gets an iterator over all predicates which apply to the given item.

View file

@ -1,7 +1,7 @@
#![feature(stmt_expr_attributes)]
#![allow(clippy::let_unit_value, invalid_value)]
use std::mem::{self, MaybeUninit};
use std::mem::MaybeUninit;
union MyOwnMaybeUninit {
value: u8,
@ -30,12 +30,24 @@ fn main() {
let _: [u8; 0] = unsafe { MaybeUninit::uninit().assume_init() };
// Was a false negative.
let _: usize = unsafe { mem::MaybeUninit::uninit().assume_init() };
let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
polymorphic::<()>();
polymorphic_maybe_uninit_array::<10>();
polymorphic_maybe_uninit::<u8>();
fn polymorphic<T>() {
// We are conservative around polymorphic types.
let _: T = unsafe { mem::MaybeUninit::uninit().assume_init() };
let _: T = unsafe { MaybeUninit::uninit().assume_init() };
}
fn polymorphic_maybe_uninit_array<const N: usize>() {
// While the type is polymorphic, MaybeUninit<u8> is not.
let _: [MaybeUninit<u8>; N] = unsafe { MaybeUninit::uninit().assume_init() };
}
fn polymorphic_maybe_uninit<T>() {
// The entire type is polymorphic, but it's wrapped in a MaybeUninit.
let _: MaybeUninit<T> = unsafe { MaybeUninit::uninit().assume_init() };
}
}

View file

@ -9,14 +9,14 @@ LL | let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
error: this call for this type may be undefined behavior
--> $DIR/uninit.rs:33:29
|
LL | let _: usize = unsafe { mem::MaybeUninit::uninit().assume_init() };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: this call for this type may be undefined behavior
--> $DIR/uninit.rs:39:29
--> $DIR/uninit.rs:41:29
|
LL | let _: T = unsafe { mem::MaybeUninit::uninit().assume_init() };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | let _: T = unsafe { MaybeUninit::uninit().assume_init() };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 3 previous errors

View file

@ -124,4 +124,12 @@ fn main() {
vec.set_len(10);
}
}
fn poly_maybe_uninit<T>() {
// We are conservative around polymorphic types.
let mut vec: Vec<MaybeUninit<T>> = Vec::with_capacity(1000);
unsafe {
vec.set_len(10);
}
}
}