/rust/registry/src/index.crates.io-6f17d22bba15001f/ring-0.17.14/src/arithmetic/inout.rs

Source (jump to first uncovered line)
// Copyright 2025 Brian Smith.
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
// OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
// CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

pub(crate) use crate::error::LenMismatchError;
use core::num::NonZeroUsize;

pub(crate) trait AliasingSlices2<T> {
    /// The pointers passed to `f` will be valid and non-null, and will not
    /// be dangling, so they can be passed to C functions.
    ///
    /// The first pointer, `r`, may be pointing to uninitialized memory for
    /// `expected_len` elements of type `T`, properly aligned and writable.
    /// `f` must not read from `r` before writing to it.
    ///
    /// The second & third pointers, `a` and `b`, point to `expected_len`
    /// values of type `T`, properly aligned.
    ///
    /// `r`, `a`, and/or `b` may alias each other only in the following ways:
    /// `ptr::eq(r, a)`, `ptr::eq(r, b)`, and/or `ptr::eq(a, b)`; i.e. they
    /// will not be "overlapping."
    ///
    /// Implementations of this trait shouldn't override this default
    /// implementation.
    #[inline(always)]
    fn with_non_dangling_non_null_pointers_ra<R>(
        self,
        expected_len: NonZeroUsize,
        f: impl FnOnce(*mut T, *const T) -> R,
    ) -> Result<R, LenMismatchError>
    where
        Self: Sized,
    {
        self.with_potentially_dangling_non_null_pointers_ra(expected_len.get(), f)
    }

    /// If `expected_len == 0` then the pointers passed to `f` may be
    /// dangling pointers, which should not be passed to C functions. In all
    /// other respects, this works like
    /// `Self::with_non_dangling_non_null_pointers_rab`.
    ///
    /// Implementations of this trait should implement this method and not
    /// `with_non_dangling_non_null_pointers_rab`. Users of this trait should
    /// use `with_non_dangling_non_null_pointers_rab` and not this.
    fn with_potentially_dangling_non_null_pointers_ra<R>(
        self,
        expected_len: usize,
        f: impl FnOnce(*mut T, *const T) -> R,
    ) -> Result<R, LenMismatchError>;
}

impl<T> AliasingSlices2<T> for &mut [T] {
    fn with_potentially_dangling_non_null_pointers_ra<R>(
        self,
        expected_len: usize,
        f: impl FnOnce(*mut T, *const T) -> R,
    ) -> Result<R, LenMismatchError> {
        let r = self;
        if r.len() != expected_len {
            return Err(LenMismatchError::new(r.len()));
        }
        Ok(f(r.as_mut_ptr(), r.as_ptr()))
    }
}

impl<T> AliasingSlices2<T> for (&mut [T], &[T]) {
    fn with_potentially_dangling_non_null_pointers_ra<R>(
        self,
        expected_len: usize,
        f: impl FnOnce(*mut T, *const T) -> R,
    ) -> Result<R, LenMismatchError> {
        let (r, a) = self;
        if r.len() != expected_len {
            return Err(LenMismatchError::new(r.len()));
        }
        if a.len() != expected_len {
            return Err(LenMismatchError::new(a.len()));
        }
        Ok(f(r.as_mut_ptr(), a.as_ptr()))
    }
}

pub(crate) trait AliasingSlices3<T> {
    /// The pointers passed to `f` will all be non-null and properly aligned,
    /// and will not be dangling.
    ///
    /// The first pointer, `r` points to potentially-uninitialized writable
    /// space for `expected_len` elements of type `T`. Accordingly, `f` must
    /// not read from `r` before writing to it.
    ///
    /// The second & third pointers, `a` and `b`, point to `expected_len`
    /// initialized values of type `T`.
    ///
    /// `r`, `a`, and/or `b` may alias each other, but only in the following
    /// ways: `ptr::eq(r, a)`, `ptr::eq(r, b)`, and/or `ptr::eq(a, b)`; they
    /// will not be "overlapping."
    ///
    /// Implementations of this trait shouldn't override this default
    /// implementation.
    #[inline(always)]
    fn with_non_dangling_non_null_pointers_rab<R>(
        self,
        expected_len: NonZeroUsize,
        f: impl FnOnce(*mut T, *const T, *const T) -> R,
    ) -> Result<R, LenMismatchError>
    where
        Self: Sized,
    {
        self.with_potentially_dangling_non_null_pointers_rab(expected_len.get(), f)
    }

    /// If `expected_len == 0` then the pointers passed to `f` may be
    /// dangling pointers, which should not be passed to C functions. In all
    /// other respects, this works like
    /// `Self::with_non_dangling_non_null_pointers_rab`.
    ///
    /// Implementations of this trait should implement this method and not
    /// `with_non_dangling_non_null_pointers_rab`. Users of this trait should
    /// use `with_non_dangling_non_null_pointers_rab` and not this.
    fn with_potentially_dangling_non_null_pointers_rab<R>(
        self,
        expected_len: usize,
        f: impl FnOnce(*mut T, *const T, *const T) -> R,
    ) -> Result<R, LenMismatchError>;
}

impl<T> AliasingSlices3<T> for &mut [T] {
    fn with_potentially_dangling_non_null_pointers_rab<R>(
        self,
        expected_len: usize,
        f: impl FnOnce(*mut T, *const T, *const T) -> R,
    ) -> Result<R, LenMismatchError> {
        <Self as AliasingSlices2<T>>::with_potentially_dangling_non_null_pointers_ra(
            self,
            expected_len,
            |r, a| f(r, r, a),
        )
    }
}

impl<T> AliasingSlices3<T> for (&mut [T], &[T], &[T]) {
    fn with_potentially_dangling_non_null_pointers_rab<R>(
        self,
        expected_len: usize,
        f: impl FnOnce(*mut T, *const T, *const T) -> R,
    ) -> Result<R, LenMismatchError> {
        let (r, a, b) = self;
        ((r, a), b).with_potentially_dangling_non_null_pointers_rab(expected_len, f)
    }
}

impl<RA, T> AliasingSlices3<T> for (RA, &[T])
where
    RA: AliasingSlices2<T>,
{
    fn with_potentially_dangling_non_null_pointers_rab<R>(
        self,
        expected_len: usize,
        f: impl FnOnce(*mut T, *const T, *const T) -> R,
    ) -> Result<R, LenMismatchError> {
        let (ra, b) = self;
        if b.len() != expected_len {
            return Err(LenMismatchError::new(b.len()));
        }
        ra.with_potentially_dangling_non_null_pointers_ra(expected_len, |r, a| f(r, a, b.as_ptr()))
    }
}

Line	Count	Source (jump to first uncovered line)
1		// Copyright 2025 Brian Smith.
2		//
3		// Permission to use, copy, modify, and/or distribute this software for any
4		// purpose with or without fee is hereby granted, provided that the above
5		// copyright notice and this permission notice appear in all copies.
6		//
7		// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
8		// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
9		// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
10		// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
11		// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
12		// OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
13		// CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
14
15		pub(crate) use crate::error::LenMismatchError;
16		use core::num::NonZeroUsize;
17
18		pub(crate) trait AliasingSlices2<T> {
19		/// The pointers passed to `f` will be valid and non-null, and will not
20		/// be dangling, so they can be passed to C functions.
21		///
22		/// The first pointer, `r`, may be pointing to uninitialized memory for
23		/// `expected_len` elements of type `T`, properly aligned and writable.
24		/// `f` must not read from `r` before writing to it.
25		///
26		/// The second & third pointers, `a` and `b`, point to `expected_len`
27		/// values of type `T`, properly aligned.
28		///
29		/// `r`, `a`, and/or `b` may alias each other only in the following ways:
30		/// `ptr::eq(r, a)`, `ptr::eq(r, b)`, and/or `ptr::eq(a, b)`; i.e. they
31		/// will not be "overlapping."
32		///
33		/// Implementations of this trait shouldn't override this default
34		/// implementation.
35		#[inline(always)]
36	0	fn with_non_dangling_non_null_pointers_ra<R>(
37	0	self,
38	0	expected_len: NonZeroUsize,
39	0	f: impl FnOnce(mut T, const T) -> R,
40	0	) -> Result<R, LenMismatchError>
41	0	where
42	0	Self: Sized,
43	0	{
44	0	self.with_potentially_dangling_non_null_pointers_ra(expected_len.get(), f)
45	0	} Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices2<u64>>::with_non_dangling_non_null_pointers_ra::<(), ring::limb::limbs_double_mod::{closure#1}> Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices2<u64>>::with_non_dangling_non_null_pointers_ra::<(), ring::arithmetic::limbs::x86_64::mont::sqr_mont5::{closure#1}>
46
47		/// If `expected_len == 0` then the pointers passed to `f` may be
48		/// dangling pointers, which should not be passed to C functions. In all
49		/// other respects, this works like
50		/// `Self::with_non_dangling_non_null_pointers_rab`.
51		///
52		/// Implementations of this trait should implement this method and not
53		/// `with_non_dangling_non_null_pointers_rab`. Users of this trait should
54		/// use `with_non_dangling_non_null_pointers_rab` and not this.
55		fn with_potentially_dangling_non_null_pointers_ra<R>(
56		self,
57		expected_len: usize,
58		f: impl FnOnce(mut T, const T) -> R,
59		) -> Result<R, LenMismatchError>;
60		}
61
62		impl<T> AliasingSlices2<T> for &mut [T] {
63	0	fn with_potentially_dangling_non_null_pointers_ra<R>(
64	0	self,
65	0	expected_len: usize,
66	0	f: impl FnOnce(mut T, const T) -> R,
67	0	) -> Result<R, LenMismatchError> {
68	0	let r = self;
69	0	if r.len() != expected_len {
70	0	return Err(LenMismatchError::new(r.len()));
71	0	}
72	0	Ok(f(r.as_mut_ptr(), r.as_ptr()))
73	0	} Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices2<u64>>::with_potentially_dangling_non_null_pointers_ra::<(), <&mut [u64] as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(ring::cpu::intel::Adx, ring::cpu::intel::Bmi2), 8, 4, &mut [u64]>::{closure#1}>::{closure#0}> Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices2<u64>>::with_potentially_dangling_non_null_pointers_ra::<(), <&mut [u64] as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 4, 1, &mut [u64]>::{closure#1}>::{closure#0}> Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices2<u64>>::with_potentially_dangling_non_null_pointers_ra::<(), <&mut [u64] as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 8, 4, &mut [u64]>::{closure#1}>::{closure#0}> Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices2<u64>>::with_potentially_dangling_non_null_pointers_ra::<(), <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(ring::cpu::intel::Adx, ring::cpu::intel::Bmi2), 8, 4, (&mut [u64], &[u64])>::{closure#1}>::{closure#0}> Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices2<u64>>::with_potentially_dangling_non_null_pointers_ra::<(), <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 4, 1, (&mut [u64], &[u64])>::{closure#1}>::{closure#0}> Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices2<u64>>::with_potentially_dangling_non_null_pointers_ra::<(), <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 8, 4, (&mut [u64], &[u64])>::{closure#1}>::{closure#0}> Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices2<u64>>::with_potentially_dangling_non_null_pointers_ra::<(), <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab<(), ring::arithmetic::bigint::elem_sub<ring::rsa::keypair::P, ring::arithmetic::montgomery::Unencoded>::{closure#0}>::{closure#0}> Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices2<u64>>::with_potentially_dangling_non_null_pointers_ra::<(), <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab<(), ring::limb::limbs_add_assign_mod::{closure#1}>::{closure#0}> Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices2<u64>>::with_potentially_dangling_non_null_pointers_ra::<(), ring::limb::limbs_double_mod::{closure#1}> Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices2<u64>>::with_potentially_dangling_non_null_pointers_ra::<(), ring::arithmetic::limbs::x86_64::mont::sqr_mont5::{closure#1}>
74		}
75
76		impl<T> AliasingSlices2<T> for (&mut [T], &[T]) {
77	0	fn with_potentially_dangling_non_null_pointers_ra<R>(
78	0	self,
79	0	expected_len: usize,
80	0	f: impl FnOnce(mut T, const T) -> R,
81	0	) -> Result<R, LenMismatchError> {
82	0	let (r, a) = self;
83	0	if r.len() != expected_len {
84	0	return Err(LenMismatchError::new(r.len()));
85	0	}
86	0	if a.len() != expected_len {
87	0	return Err(LenMismatchError::new(a.len()));
88	0	}
89	0	Ok(f(r.as_mut_ptr(), a.as_ptr()))
90	0	} Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices2<u64>>::with_potentially_dangling_non_null_pointers_ra::<(), <((&mut [u64], &[u64]), &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(ring::cpu::intel::Adx, ring::cpu::intel::Bmi2), 8, 4, (&mut [u64], &[u64], &[u64])>::{closure#1}>::{closure#0}> Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices2<u64>>::with_potentially_dangling_non_null_pointers_ra::<(), <((&mut [u64], &[u64]), &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 4, 1, (&mut [u64], &[u64], &[u64])>::{closure#1}>::{closure#0}> Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices2<u64>>::with_potentially_dangling_non_null_pointers_ra::<(), <((&mut [u64], &[u64]), &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 8, 4, (&mut [u64], &[u64], &[u64])>::{closure#1}>::{closure#0}>
91		}
92
93		pub(crate) trait AliasingSlices3<T> {
94		/// The pointers passed to `f` will all be non-null and properly aligned,
95		/// and will not be dangling.
96		///
97		/// The first pointer, `r` points to potentially-uninitialized writable
98		/// space for `expected_len` elements of type `T`. Accordingly, `f` must
99		/// not read from `r` before writing to it.
100		///
101		/// The second & third pointers, `a` and `b`, point to `expected_len`
102		/// initialized values of type `T`.
103		///
104		/// `r`, `a`, and/or `b` may alias each other, but only in the following
105		/// ways: `ptr::eq(r, a)`, `ptr::eq(r, b)`, and/or `ptr::eq(a, b)`; they
106		/// will not be "overlapping."
107		///
108		/// Implementations of this trait shouldn't override this default
109		/// implementation.
110		#[inline(always)]
111	0	fn with_non_dangling_non_null_pointers_rab<R>(
112	0	self,
113	0	expected_len: NonZeroUsize,
114	0	f: impl FnOnce(mut T, const T, *const T) -> R,
115	0	) -> Result<R, LenMismatchError>
116	0	where
117	0	Self: Sized,
118	0	{
119	0	self.with_potentially_dangling_non_null_pointers_rab(expected_len.get(), f)
120	0	} Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_non_dangling_non_null_pointers_rab::<(), ring::arithmetic::bigint::elem_sub<ring::rsa::keypair::P, ring::arithmetic::montgomery::Unencoded>::{closure#0}> Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices3<u64>>::with_non_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(ring::cpu::intel::Adx, ring::cpu::intel::Bmi2), 8, 4, &mut [u64]>::{closure#1}> Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices3<u64>>::with_non_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 4, 1, &mut [u64]>::{closure#1}> Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices3<u64>>::with_non_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 8, 4, &mut [u64]>::{closure#1}> Unexecuted instantiation: <(&mut [u64], &[u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_non_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(ring::cpu::intel::Adx, ring::cpu::intel::Bmi2), 8, 4, (&mut [u64], &[u64], &[u64])>::{closure#1}> Unexecuted instantiation: <(&mut [u64], &[u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_non_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 4, 1, (&mut [u64], &[u64], &[u64])>::{closure#1}> Unexecuted instantiation: <(&mut [u64], &[u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_non_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 8, 4, (&mut [u64], &[u64], &[u64])>::{closure#1}> Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_non_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(ring::cpu::intel::Adx, ring::cpu::intel::Bmi2), 8, 4, (&mut [u64], &[u64])>::{closure#1}> Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_non_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 4, 1, (&mut [u64], &[u64])>::{closure#1}> Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_non_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 8, 4, (&mut [u64], &[u64])>::{closure#1}> Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_non_dangling_non_null_pointers_rab::<(), ring::limb::limbs_add_assign_mod::{closure#1}>
121
122		/// If `expected_len == 0` then the pointers passed to `f` may be
123		/// dangling pointers, which should not be passed to C functions. In all
124		/// other respects, this works like
125		/// `Self::with_non_dangling_non_null_pointers_rab`.
126		///
127		/// Implementations of this trait should implement this method and not
128		/// `with_non_dangling_non_null_pointers_rab`. Users of this trait should
129		/// use `with_non_dangling_non_null_pointers_rab` and not this.
130		fn with_potentially_dangling_non_null_pointers_rab<R>(
131		self,
132		expected_len: usize,
133		f: impl FnOnce(mut T, const T, *const T) -> R,
134		) -> Result<R, LenMismatchError>;
135		}
136
137		impl<T> AliasingSlices3<T> for &mut [T] {
138	0	fn with_potentially_dangling_non_null_pointers_rab<R>(
139	0	self,
140	0	expected_len: usize,
141	0	f: impl FnOnce(mut T, const T, *const T) -> R,
142	0	) -> Result<R, LenMismatchError> {
143	0	<Self as AliasingSlices2<T>>::with_potentially_dangling_non_null_pointers_ra(
144	0	self,
145	0	expected_len,
146	0	\|r, a\| f(r, r, a), Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(ring::cpu::intel::Adx, ring::cpu::intel::Bmi2), 8, 4, &mut [u64]>::{closure#1}>::{closure#0} Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 4, 1, &mut [u64]>::{closure#1}>::{closure#0} Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 8, 4, &mut [u64]>::{closure#1}>::{closure#0}
147	0	)
148	0	} Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(ring::cpu::intel::Adx, ring::cpu::intel::Bmi2), 8, 4, &mut [u64]>::{closure#1}> Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 4, 1, &mut [u64]>::{closure#1}> Unexecuted instantiation: <&mut [u64] as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 8, 4, &mut [u64]>::{closure#1}>
149		}
150
151		impl<T> AliasingSlices3<T> for (&mut [T], &[T], &[T]) {
152	0	fn with_potentially_dangling_non_null_pointers_rab<R>(
153	0	self,
154	0	expected_len: usize,
155	0	f: impl FnOnce(mut T, const T, *const T) -> R,
156	0	) -> Result<R, LenMismatchError> {
157	0	let (r, a, b) = self;
158	0	((r, a), b).with_potentially_dangling_non_null_pointers_rab(expected_len, f)
159	0	} Unexecuted instantiation: <(&mut [u64], &[u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(ring::cpu::intel::Adx, ring::cpu::intel::Bmi2), 8, 4, (&mut [u64], &[u64], &[u64])>::{closure#1}> Unexecuted instantiation: <(&mut [u64], &[u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 4, 1, (&mut [u64], &[u64], &[u64])>::{closure#1}> Unexecuted instantiation: <(&mut [u64], &[u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 8, 4, (&mut [u64], &[u64], &[u64])>::{closure#1}>
160		}
161
162		impl<RA, T> AliasingSlices3<T> for (RA, &[T])
163		where
164		RA: AliasingSlices2<T>,
165		{
166	0	fn with_potentially_dangling_non_null_pointers_rab<R>(
167	0	self,
168	0	expected_len: usize,
169	0	f: impl FnOnce(mut T, const T, *const T) -> R,
170	0	) -> Result<R, LenMismatchError> {
171	0	let (ra, b) = self;
172	0	if b.len() != expected_len {
173	0	return Err(LenMismatchError::new(b.len()));
174	0	}
175	0	ra.with_potentially_dangling_non_null_pointers_ra(expected_len, \|r, a\| f(r, a, b.as_ptr())) Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(ring::cpu::intel::Adx, ring::cpu::intel::Bmi2), 8, 4, (&mut [u64], &[u64])>::{closure#1}>::{closure#0} Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 4, 1, (&mut [u64], &[u64])>::{closure#1}>::{closure#0} Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 8, 4, (&mut [u64], &[u64])>::{closure#1}>::{closure#0} Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::bigint::elem_sub<ring::rsa::keypair::P, ring::arithmetic::montgomery::Unencoded>::{closure#0}>::{closure#0} Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::limb::limbs_add_assign_mod::{closure#1}>::{closure#0} Unexecuted instantiation: <((&mut [u64], &[u64]), &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(ring::cpu::intel::Adx, ring::cpu::intel::Bmi2), 8, 4, (&mut [u64], &[u64], &[u64])>::{closure#1}>::{closure#0} Unexecuted instantiation: <((&mut [u64], &[u64]), &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 4, 1, (&mut [u64], &[u64], &[u64])>::{closure#1}>::{closure#0} Unexecuted instantiation: <((&mut [u64], &[u64]), &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 8, 4, (&mut [u64], &[u64], &[u64])>::{closure#1}>::{closure#0}
176	0	} Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(ring::cpu::intel::Adx, ring::cpu::intel::Bmi2), 8, 4, (&mut [u64], &[u64])>::{closure#1}> Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 4, 1, (&mut [u64], &[u64])>::{closure#1}> Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 8, 4, (&mut [u64], &[u64])>::{closure#1}> Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::bigint::elem_sub<ring::rsa::keypair::P, ring::arithmetic::montgomery::Unencoded>::{closure#0}> Unexecuted instantiation: <(&mut [u64], &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::limb::limbs_add_assign_mod::{closure#1}> Unexecuted instantiation: <((&mut [u64], &[u64]), &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(ring::cpu::intel::Adx, ring::cpu::intel::Bmi2), 8, 4, (&mut [u64], &[u64], &[u64])>::{closure#1}> Unexecuted instantiation: <((&mut [u64], &[u64]), &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 4, 1, (&mut [u64], &[u64], &[u64])>::{closure#1}> Unexecuted instantiation: <((&mut [u64], &[u64]), &[u64]) as ring::arithmetic::inout::AliasingSlices3<u64>>::with_potentially_dangling_non_null_pointers_rab::<(), ring::arithmetic::ffi::bn_mul_mont_ffi<(), 8, 4, (&mut [u64], &[u64], &[u64])>::{closure#1}>
177		}

Coverage Report

Created: 2025-07-01 06:46