Skip to content

Commit

Permalink
size_of_val_raw: for length 0 this is safe to call
Browse files Browse the repository at this point in the history
  • Loading branch information
RalfJung committed Jun 8, 2024
1 parent 16e8803 commit 26f2b66
Show file tree
Hide file tree
Showing 4 changed files with 43 additions and 0 deletions.
2 changes: 2 additions & 0 deletions library/core/src/alloc/layout.rs
Original file line number Diff line number Diff line change
Expand Up @@ -183,6 +183,8 @@ impl Layout {
/// - a [slice], then the length of the slice tail must be an initialized
/// integer, and the size of the *entire value*
/// (dynamic tail length + statically sized prefix) must fit in `isize`.
/// For the special case where the dynamic tail length is 0, this function
/// is safe to call.
/// - a [trait object], then the vtable part of the pointer must point
/// to a valid vtable for the type `T` acquired by an unsizing coercion,
/// and the size of the *entire value*
Expand Down
8 changes: 8 additions & 0 deletions library/core/src/mem/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -359,6 +359,12 @@ pub const fn size_of_val<T: ?Sized>(val: &T) -> usize {
/// - a [slice], then the length of the slice tail must be an initialized
/// integer, and the size of the *entire value*
/// (dynamic tail length + statically sized prefix) must fit in `isize`.
/// For the special case where the dynamic tail length is 0, this function
/// is safe to call.
// NOTE: the reason this is safe is that if an overflow were to occur already with size 0,
// then we would stop compilation as even the "statically known" part of the type would
// already be too big (or the call may be in dead code and optimized away, but then it
// doesn't matter).
/// - a [trait object], then the vtable part of the pointer must point
/// to a valid vtable acquired by an unsizing coercion, and the size
/// of the *entire value* (dynamic tail length + statically sized prefix)
Expand Down Expand Up @@ -506,6 +512,8 @@ pub const fn align_of_val<T: ?Sized>(val: &T) -> usize {
/// - a [slice], then the length of the slice tail must be an initialized
/// integer, and the size of the *entire value*
/// (dynamic tail length + statically sized prefix) must fit in `isize`.
/// For the special case where the dynamic tail length is 0, this function
/// is safe to call.
/// - a [trait object], then the vtable part of the pointer must point
/// to a valid vtable acquired by an unsizing coercion, and the size
/// of the *entire value* (dynamic tail length + statically sized prefix)
Expand Down
29 changes: 29 additions & 0 deletions tests/ui/layout/size-of-val-raw-too-big.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,29 @@
//@ build-fail
//@ compile-flags: --target i686-unknown-linux-gnu --crate-type lib
//@ needs-llvm-components: x86
//@ error-pattern: too big for the current architecture
#![feature(no_core, lang_items, intrinsics)]
#![allow(internal_features)]
#![no_std]
#![no_core]

#[lang = "sized"]
pub trait Sized {}
#[lang = "copy"]
pub trait Copy: Sized {}

// 0x7fffffff is fine, but with the padding for the unsized tail it is too big.
#[repr(C)]
pub struct Example([u8; 0x7fffffff], [u16]);

extern "rust-intrinsic" {
pub fn size_of_val<T: ?Sized>(_: *const T) -> usize;
}

// We guarantee that with length 0, `size_of_val_raw` (which calls the `size_of_val` intrinsic)
// is safe to call. The compiler aborts execution if a length of 0 would overflow.
// So let's construct a case where length 0 just barely overflows, and ensure that
// does abort execution.
pub fn check(x: *const Example) {
unsafe { size_of_val(x); }
}
4 changes: 4 additions & 0 deletions tests/ui/layout/size-of-val-raw-too-big.stderr
Original file line number Diff line number Diff line change
@@ -0,0 +1,4 @@
error: values of the type `Example` are too big for the current architecture

error: aborting due to 1 previous error

0 comments on commit 26f2b66

Please sign in to comment.