rust: upgrade to Rust 1.72.1 (ae6df65d) · Commits · git / linux-nf

Documentation/process/changes.rst

+1 −1

Original line number	Diff line number	Diff line
		@@ -31,7 +31,7 @@ you probably needn't concern yourself with pcmciautils.
		====================== =============== ========================================
		GNU C 5.1 gcc --version
		Clang/LLVM (optional) 11.0.0 clang --version
		Rust (optional) 1.71.1 rustc --version
		Rust (optional) 1.72.1 rustc --version
		bindgen (optional) 0.65.1 bindgen --version
		GNU make 3.82 make --version
		bash 4.2 bash --version

rust/alloc/alloc.rs

+5 −4

Original line number	Diff line number	Diff line
		@@ -6,8 +6,10 @@

		#[cfg(not(test))]
		use core::intrinsics;
		#[cfg(all(bootstrap, not(test)))]
		use core::intrinsics::{min_align_of_val, size_of_val};

		#[cfg(all(bootstrap, not(test)))]
		use core::ptr::Unique;
		#[cfg(not(test))]
		use core::ptr::{self, NonNull};
		@@ -40,7 +42,6 @@
		#[rustc_nounwind]
		fn __rust_alloc_zeroed(size: usize, align: usize) -> *mut u8;

		#[cfg(not(bootstrap))]
		static __rust_no_alloc_shim_is_unstable: u8;
		}

		@@ -98,7 +99,6 @@ pub unsafe fn alloc(layout: Layout) -> *mut u8 {
		unsafe {
		// Make sure we don't accidentally allow omitting the allocator shim in
		// stable code until it is actually stabilized.
		#[cfg(not(bootstrap))]
		core::ptr::read_volatile(&__rust_no_alloc_shim_is_unstable);

		__rust_alloc(layout.size(), layout.align())
		@@ -339,14 +339,15 @@ unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
		}
		}

		#[cfg_attr(not(test), lang = "box_free")]
		#[cfg(all(bootstrap, not(test)))]
		#[lang = "box_free"]
		#[inline]
		// This signature has to be the same as `Box`, otherwise an ICE will happen.
		// When an additional parameter to `Box` is added (like `A: Allocator`), this has to be added here as
		// well.
		// For example if `Box` is changed to `struct Box<T: ?Sized, A: Allocator>(Unique<T>, A)`,
		// this function has to be changed to `fn box_free<T: ?Sized, A: Allocator>(Unique<T>, A)` as well.
		pub(crate) unsafe fn box_free<T: ?Sized, A: Allocator>(ptr: Unique<T>, alloc: A) {
		unsafe fn box_free<T: ?Sized, A: Allocator>(ptr: Unique<T>, alloc: A) {
		unsafe {
		let size = size_of_val(ptr.as_ref());
		let align = min_align_of_val(ptr.as_ref());

rust/alloc/boxed.rs

+9 −1

Original line number	Diff line number	Diff line
		@@ -1215,8 +1215,16 @@ pub const fn into_pin(boxed: Self) -> Pin<Self>

		#[stable(feature = "rust1", since = "1.0.0")]
		unsafe impl<#[may_dangle] T: ?Sized, A: Allocator> Drop for Box<T, A> {
		#[inline]
		fn drop(&mut self) {
		// FIXME: Do nothing, drop is currently performed by compiler.
		// the T in the Box is dropped by the compiler before the destructor is run

		let ptr = self.0;

		unsafe {
		let layout = Layout::for_value_raw(ptr.as_ptr());
		self.1.deallocate(From::from(ptr.cast()), layout)
		}
		}
		}

rust/alloc/lib.rs

+5 −5

Original line number	Diff line number	Diff line
		@@ -58,6 +58,11 @@
		//! [`Rc`]: rc
		//! [`RefCell`]: core::cell

		// To run alloc tests without x.py without ending up with two copies of alloc, Miri needs to be
		// able to "empty" this crate. See <https://github.com/rust-lang/miri-test-libstd/issues/4>.
		// rustc itself never sets the feature, so this line has no affect there.
		#![cfg(any(not(feature = "miri-test-libstd"), test, doctest))]
		//
		#![allow(unused_attributes)]
		#![stable(feature = "alloc", since = "1.36.0")]
		#![doc(
		@@ -77,11 +82,6 @@
		))]
		#![no_std]
		#![needs_allocator]
		// To run alloc tests without x.py without ending up with two copies of alloc, Miri needs to be
		// able to "empty" this crate. See <https://github.com/rust-lang/miri-test-libstd/issues/4>.
		// rustc itself never sets the feature, so this line has no affect there.
		#![cfg(any(not(feature = "miri-test-libstd"), test, doctest))]
		//
		// Lints:
		#![deny(unsafe_op_in_unsafe_fn)]
		#![deny(fuzzy_provenance_casts)]

rust/alloc/vec/drain_filter.rs→rust/alloc/vec/extract_if.rs

+115 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: Apache-2.0 OR MIT

		use crate::alloc::{Allocator, Global};
		use core::mem::{ManuallyDrop, SizedTypeProperties};
		use core::ptr;
		use core::slice;

		@@ -9,20 +8,21 @@

		/// An iterator which uses a closure to determine if an element should be removed.
		///
		/// This struct is created by [`Vec::drain_filter`].
		/// This struct is created by [`Vec::extract_if`].
		/// See its documentation for more.
		///
		/// # Example
		///
		/// ```
		/// #![feature(drain_filter)]
		/// #![feature(extract_if)]
		///
		/// let mut v = vec![0, 1, 2];
		/// let iter: std::vec::DrainFilter<'_, _, _> = v.drain_filter(\|x\| *x % 2 == 0);
		/// let iter: std::vec::ExtractIf<'_, _, _> = v.extract_if(\|x\| *x % 2 == 0);
		/// ```
		#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
		#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
		#[derive(Debug)]
		pub struct DrainFilter<
		#[must_use = "iterators are lazy and do nothing unless consumed"]
		pub struct ExtractIf<
		'a,
		T,
		F,
		@@ -39,15 +39,9 @@ pub struct DrainFilter<
		pub(super) old_len: usize,
		/// The filter test predicate.
		pub(super) pred: F,
		/// A flag that indicates a panic has occurred in the filter test predicate.
		/// This is used as a hint in the drop implementation to prevent consumption
		/// of the remainder of the `DrainFilter`. Any unprocessed items will be
		/// backshifted in the `vec`, but no further items will be dropped or
		/// tested by the filter predicate.
		pub(super) panic_flag: bool,
		}

		impl<T, F, A: Allocator> DrainFilter<'_, T, F, A>
		impl<T, F, A: Allocator> ExtractIf<'_, T, F, A>
		where
		F: FnMut(&mut T) -> bool,
		{
		@@ -57,63 +51,10 @@ impl<T, F, A: Allocator> DrainFilter<'_, T, F, A>
		pub fn allocator(&self) -> &A {
		self.vec.allocator()
		}

		/// Keep unyielded elements in the source `Vec`.
		///
		/// # Examples
		///
		/// ```
		/// #![feature(drain_filter)]
		/// #![feature(drain_keep_rest)]
		///
		/// let mut vec = vec!['a', 'b', 'c'];
		/// let mut drain = vec.drain_filter(\|_\| true);
		///
		/// assert_eq!(drain.next().unwrap(), 'a');
		///
		/// // This call keeps 'b' and 'c' in the vec.
		/// drain.keep_rest();
		///
		/// // If we wouldn't call `keep_rest()`,
		/// // `vec` would be empty.
		/// assert_eq!(vec, ['b', 'c']);
		/// ```
		#[unstable(feature = "drain_keep_rest", issue = "101122")]
		pub fn keep_rest(self) {
		// At this moment layout looks like this:
		//
		// _____________________/-- old_len
		// / \
		// [kept] [yielded] [tail]
		// \_______/ ^-- idx
		// \-- del
		//
		// Normally `Drop` impl would drop [tail] (via .for_each(drop), ie still calling `pred`)
		//
		// 1. Move [tail] after [kept]
		// 2. Update length of the original vec to `old_len - del`
		// a. In case of ZST, this is the only thing we want to do
		// 3. Do not drop self, as everything is put in a consistent state already, there is nothing to do
		let mut this = ManuallyDrop::new(self);

		unsafe {
		// ZSTs have no identity, so we don't need to move them around.
		if !T::IS_ZST && this.idx < this.old_len && this.del > 0 {
		let ptr = this.vec.as_mut_ptr();
		let src = ptr.add(this.idx);
		let dst = src.sub(this.del);
		let tail_len = this.old_len - this.idx;
		src.copy_to(dst, tail_len);
		}

		let new_len = this.old_len - this.del;
		this.vec.set_len(new_len);
		}
		}
		}

		#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
		impl<T, F, A: Allocator> Iterator for DrainFilter<'_, T, F, A>
		#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
		impl<T, F, A: Allocator> Iterator for ExtractIf<'_, T, F, A>
		where
		F: FnMut(&mut T) -> bool,
		{
		@@ -124,9 +65,7 @@ fn next(&mut self) -> Option<T> {
		while self.idx < self.old_len {
		let i = self.idx;
		let v = slice::from_raw_parts_mut(self.vec.as_mut_ptr(), self.old_len);
		self.panic_flag = true;
		let drained = (self.pred)(&mut v[i]);
		self.panic_flag = false;
		// Update the index after the predicate is called. If the index
		// is updated prior and the predicate panics, the element at this
		// index would be leaked.
		@@ -150,50 +89,27 @@ fn size_hint(&self) -> (usize, Option<usize>) {
		}
		}

		#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
		impl<T, F, A: Allocator> Drop for DrainFilter<'_, T, F, A>
		where
		F: FnMut(&mut T) -> bool,
		{
		fn drop(&mut self) {
		struct BackshiftOnDrop<'a, 'b, T, F, A: Allocator>
		where
		F: FnMut(&mut T) -> bool,
		{
		drain: &'b mut DrainFilter<'a, T, F, A>,
		}

		impl<'a, 'b, T, F, A: Allocator> Drop for BackshiftOnDrop<'a, 'b, T, F, A>
		#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
		impl<T, F, A: Allocator> Drop for ExtractIf<'_, T, F, A>
		where
		F: FnMut(&mut T) -> bool,
		{
		fn drop(&mut self) {
		unsafe {
		if self.drain.idx < self.drain.old_len && self.drain.del > 0 {
		if self.idx < self.old_len && self.del > 0 {
		// This is a pretty messed up state, and there isn't really an
		// obviously right thing to do. We don't want to keep trying
		// to execute `pred`, so we just backshift all the unprocessed
		// elements and tell the vec that they still exist. The backshift
		// is required to prevent a double-drop of the last successfully
		// drained item prior to a panic in the predicate.
		let ptr = self.drain.vec.as_mut_ptr();
		let src = ptr.add(self.drain.idx);
		let dst = src.sub(self.drain.del);
		let tail_len = self.drain.old_len - self.drain.idx;
		let ptr = self.vec.as_mut_ptr();
		let src = ptr.add(self.idx);
		let dst = src.sub(self.del);
		let tail_len = self.old_len - self.idx;
		src.copy_to(dst, tail_len);
		}
		self.drain.vec.set_len(self.drain.old_len - self.drain.del);
		}
		}
		}

		let backshift = BackshiftOnDrop { drain: self };

		// Attempt to consume any remaining elements if the filter predicate
		// has not yet panicked. We'll backshift any remaining elements
		// whether we've already panicked or if the consumption here panics.
		if !backshift.drain.panic_flag {
		backshift.drain.for_each(drop);
		self.vec.set_len(self.old_len - self.del);
		}
		}
		}