As with MaybeUninit::assume_init, it is up to the caller to guarantee that the values really are in an initialized state. Calling this when the content is not yet fully initialized causes immediate undefined behavior.
As with MaybeUninit::assume_init, it is up to the caller to guarantee that the value really is in an initialized state. Calling this when the content is not yet fully initialized causes immediate undefined behavior.
This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same NonNull pointer.
The non-null pointer must point to a block of memory allocated by the global allocator.
The safety conditions are described in the [memory layout] section. Note that the [considerations for unsafe code] apply to all Box<T> values.
This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.
The non-null pointer must point to a block of memory allocated by alloc.
The safety conditions are described in the [memory layout] section. Note that the [considerations for unsafe code] apply to all Box<T, A> values.
This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.
The raw pointer must point to a block of memory allocated by the global allocator.
The safety conditions are described in the [memory layout] section. Note that the [considerations for unsafe code] apply to all Box<T> values.
This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.
The raw pointer must point to a block of memory allocated by alloc.
The safety conditions are described in the [memory layout] section. Note that the [considerations for unsafe code] apply to all Box<T, A> values.
The caller must ensure that the slice remains a max-heap, i.e. for all indices 0 < i < slice.len(), slice[(i - 1) / 2] >= slice[i], before the borrow ends and the binary heap is used.
This should only ever be called with a pointer that was earlier obtained by calling CString::into_raw, and the memory it points to must not be accessed through any other pointer during the lifetime of reconstructed CString. Other usage (e.g., trying to take ownership of a string that was allocated by foreign code) is likely to lead to undefined behavior or allocator corruption.
This function does not validate ownership of the raw pointer's memory. A double-free may occur if the function is called twice on the same raw pointer. Additionally, the caller must ensure the pointer is not dangling.
It should be noted that the length isn't just "recomputed," but that the recomputed length must match the original length from the CString::into_raw call. This means the CString::into_raw/from_raw methods should not be used when passing the string to C functions that can modify the string's length.
> Note: If you need to borrow a string that was allocated by > foreign code, use CStr. If you need to take ownership of > a string that was allocated by foreign code, you will need to > make your own provisions for freeing it appropriately, likely > with the foreign code's API to do that.
As with MaybeUninit::assume_init, it is up to the caller to guarantee that the inner value really is in an initialized state. Calling this when the content is not yet fully initialized causes immediate undefined behavior.
The pointer must have been obtained through Rc::into_raw and must satisfy the same layout requirements specified in Rc::from_raw_in[from_raw_in]. The associated Rc instance must be valid (i.e. the strong count must be at least 1) when invoking this method, and ptr must point to a block of memory allocated by the global allocator. This method can be used to release the final Rc and backing storage, but should not be called after the final Rc has been released.
The pointer must have been obtained through Rc::into_rawand must satisfy the same layout requirements specified in Rc::from_raw_in[from_raw_in]. The associated Rc instance must be valid (i.e. the strong count must be at least 1) when invoking this method, and ptr must point to a block of memory allocated by alloc. This method can be used to release the final Rc and backing storage, but should not be called after the final Rc has been released.
Creating a Rc<T> from a pointer other than one returned from Rc<U>::into_raw[into_raw] or Rc<U>::into_raw_with_allocator[into_raw_with_allocator] is undefined behavior.
If U is sized, it must have the same size and alignment as T. This is trivially true if U is T.
If U is unsized, its data pointer must have the same size and alignment as T. This is trivially true if Rc<U> was constructed through Rc<T> and then converted to Rc<U> through an [unsized coercion].
Note that if U or U's data pointer is not T but has the same size and alignment, this is basically like transmuting references of different types. See mem::transmute[transmute] for more information on what restrictions apply in this case.
The raw pointer must point to a block of memory allocated by the global allocator
The user of from_raw has to make sure a specific value of T is only dropped once.
This function is unsafe because improper use may lead to memory unsafety, even if the returned Rc<T> is never accessed.
Creating a Rc<T, A> from a pointer other than one returned from Rc<U, A>::into_raw[into_raw] or Rc<U, A>::into_raw_with_allocator[into_raw_with_allocator] is undefined behavior.
If U is sized, it must have the same size and alignment as T. This is trivially true if U is T.
If U is unsized, its data pointer must have the same size and alignment as T. This is trivially true if Rc<U, A> was constructed through Rc<T, A> and then converted to Rc<U, A> through an [unsized coercion].
Note that if U or U's data pointer is not T but has the same size and alignment, this is basically like transmuting references of different types. See mem::transmute[transmute] for more information on what restrictions apply in this case.
The raw pointer must point to a block of memory allocated by alloc
The user of from_raw has to make sure a specific value of T is only dropped once.
This function is unsafe because improper use may lead to memory unsafety, even if the returned Rc<T, A> is never accessed.
If any other Rc or Weak pointers to the same allocation exist, then they must not be dereferenced or have active borrows for the duration of the returned borrow, and their inner type must be exactly the same as the inner type of this Rc (including lifetimes). This is trivially the case if no such pointers exist, for example immediately after Rc::new.
The pointer must have been obtained through Rc::into_raw and must satisfy the same layout requirements specified in Rc::from_raw_in. The associated Rc instance must be valid (i.e. the strong count must be at least 1) for the duration of this method, and ptr must point to a block of memory allocated by the global allocator.
The pointer must have been obtained through Rc::into_raw and must satisfy the same layout requirements specified in Rc::from_raw_in[from_raw_in]. The associated Rc instance must be valid (i.e. the strong count must be at least 1) for the duration of this method, and ptr must point to a block of memory allocated by alloc.
The pointer must have originated from the into_raw and must still own its potential weak reference, and ptr must point to a block of memory allocated by the global allocator.
It is allowed for the strong count to be 0 at the time of calling this. Nevertheless, this takes ownership of one weak reference currently represented as a raw pointer (the weak count is not modified by this operation) and therefore it must be paired with a previous call to into_raw.
The pointer must have originated from the into_raw and must still own its potential weak reference, and ptr must point to a block of memory allocated by alloc.
It is allowed for the strong count to be 0 at the time of calling this. Nevertheless, this takes ownership of one weak reference currently represented as a raw pointer (the weak count is not modified by this operation) and therefore it must be paired with a previous call to into_raw.
This function is unsafe because the returned &mut Vec allows writing bytes which are not valid UTF-8. If this constraint is violated, using the original String after dropping the &mut Vec may violate memory safety, as the rest of the standard library assumes that Strings are valid UTF-8.
This is highly unsafe, due to the number of invariants that aren't checked:
all safety requirements for Vec::<u8>::from_raw_parts.
all safety requirements for String::from_utf8_unchecked.
Violating these may cause problems like corrupting the allocator's internal data structures. For example, it is normally not safe to build a String from a pointer to a C char array containing UTF-8 _unless_ you are certain that array was originally allocated by the Rust standard library's allocator.
The ownership of buf is effectively transferred to the String which may then deallocate, reallocate or change the contents of memory pointed to by the pointer at will. Ensure that nothing else uses the pointer after calling this function.
This function is unsafe because it does not check that the bytes passed to it are valid UTF-8. If this constraint is violated, it may cause memory unsafety issues with future users of the String, as the rest of the standard library assumes that Strings are valid UTF-8.
As with MaybeUninit::assume_init, it is up to the caller to guarantee that the inner value really is in an initialized state. Calling this when the content is not yet fully initialized causes immediate undefined behavior.
The pointer must have been obtained through Arc::into_raw and must satisfy the same layout requirements specified in Arc::from_raw_in[from_raw_in]. The associated Arc instance must be valid (i.e. the strong count must be at least 1) when invoking this method, and ptr must point to a block of memory allocated by the global allocator. This method can be used to release the final Arc and backing storage, but should not be called after the final Arc has been released.
The pointer must have been obtained through Arc::into_raw and must satisfy the same layout requirements specified in Arc::from_raw_in[from_raw_in]. The associated Arc instance must be valid (i.e. the strong count must be at least 1) when invoking this method, and ptr must point to a block of memory allocated by alloc. This method can be used to release the final Arc and backing storage, but should not be called after the final Arc has been released.
Creating a Arc<T> from a pointer other than one returned from Arc<U>::into_raw[into_raw] or Arc<U>::into_raw_with_allocator[into_raw_with_allocator] is undefined behavior.
If U is sized, it must have the same size and alignment as T. This is trivially true if U is T.
If U is unsized, its data pointer must have the same size and alignment as T. This is trivially true if Arc<U> was constructed through Arc<T> and then converted to Arc<U> through an [unsized coercion].
Note that if U or U's data pointer is not T but has the same size and alignment, this is basically like transmuting references of different types. See mem::transmute[transmute] for more information on what restrictions apply in this case.
The raw pointer must point to a block of memory allocated by the global allocator.
The user of from_raw has to make sure a specific value of T is only dropped once.
This function is unsafe because improper use may lead to memory unsafety, even if the returned Arc<T> is never accessed.
Creating a Arc<T, A> from a pointer other than one returned from Arc<U, A>::into_raw[into_raw] or Arc<U, A>::into_raw_with_allocator[into_raw_with_allocator] is undefined behavior.
If U is sized, it must have the same size and alignment as T. This is trivially true if U is T.
If U is unsized, its data pointer must have the same size and alignment as T. This is trivially true if Arc<U, A> was constructed through Arc<T, A> and then converted to Arc<U, A> through an [unsized coercion].
Note that if U or U's data pointer is not T but has the same size and alignment, this is basically like transmuting references of different types. See mem::transmute[transmute] for more information on what restrictions apply in this case.
The raw pointer must point to a block of memory allocated by alloc
The user of from_raw has to make sure a specific value of T is only dropped once.
This function is unsafe because improper use may lead to memory unsafety, even if the returned Arc<T> is never accessed.
If any other Arc or Weak pointers to the same allocation exist, then they must not be dereferenced or have active borrows for the duration of the returned borrow, and their inner type must be exactly the same as the inner type of this Arc (including lifetimes). This is trivially the case if no such pointers exist, for example immediately after Arc::new.
The pointer must have been obtained through Arc::into_raw and must satisfy the same layout requirements specified in Arc::from_raw_in[from_raw_in]. The associated Arc instance must be valid (i.e. the strong count must be at least 1) for the duration of this method, and ptr must point to a block of memory allocated by the global allocator.
The pointer must have been obtained through Arc::into_raw and must satisfy the same layout requirements specified in Arc::from_raw_in[from_raw_in]. The associated Arc instance must be valid (i.e. the strong count must be at least 1) for the duration of this method, and ptr must point to a block of memory allocated by alloc.
The pointer must have originated from the into_raw and must still own its potential weak reference, and must point to a block of memory allocated by global allocator.
It is allowed for the strong count to be 0 at the time of calling this. Nevertheless, this takes ownership of one weak reference currently represented as a raw pointer (the weak count is not modified by this operation) and therefore it must be paired with a previous call to into_raw.
The pointer must have originated from the into_raw and must still own its potential weak reference, and must point to a block of memory allocated by alloc.
It is allowed for the strong count to be 0 at the time of calling this. Nevertheless, this takes ownership of one weak reference currently represented as a raw pointer (the weak count is not modified by this operation) and therefore it must be paired with a previous call to into_raw.
This is highly unsafe, due to the number of invariants that aren't checked:
ptr must have been allocated using the global allocator, such as via the alloc::alloc function.
T needs to have the same alignment as what ptr was allocated with. (T having a less strict alignment is not sufficient, the alignment really needs to be equal to satisfy the dealloc requirement that memory must be allocated and deallocated with the same layout.)
The size of T times the capacity (i.e. the allocated size in bytes) needs to be the same size as the pointer was allocated with. (Because similar to alignment, dealloc must be called with the same layout size.)
length needs to be less than or equal to capacity.
The first length values must be properly initialized values of type T.
capacity needs to be the capacity that the pointer was allocated with.
The allocated size in bytes must be no larger than isize::MAX. See the safety documentation of pointer::offset.
These requirements are always upheld by any ptr that has been allocated via Vec<T>. Other allocation sources are allowed if the invariants are upheld.
Violating these may cause problems like corrupting the allocator's internal data structures. For example it is normally not safe to build a Vec<u8> from a pointer to a C char array with length size_t, doing so is only safe if the array was initially allocated by a Vec or String. It's also not safe to build one from a Vec<u16> and its length, because the allocator cares about the alignment, and these two types have different alignments. The buffer was allocated with alignment 2 (for u16), but after turning it into a Vec<u8> it'll be deallocated with alignment 1. To avoid these issues, it is often preferable to do casting/transmuting using NonNull::slice_from_raw_parts instead.
The ownership of ptr is effectively transferred to the Vec<T> which may then deallocate, reallocate or change the contents of memory pointed to by the pointer at will. Ensure that nothing else uses the pointer after calling this function.
This is highly unsafe, due to the number of invariants that aren't checked:
ptr must be [currently allocated] via the given allocator alloc.
T needs to have the same alignment as what ptr was allocated with. (T having a less strict alignment is not sufficient, the alignment really needs to be equal to satisfy the dealloc requirement that memory must be allocated and deallocated with the same layout.)
The size of T times the capacity (i.e. the allocated size in bytes) needs to be the same size as the pointer was allocated with. (Because similar to alignment, dealloc must be called with the same layout size.)
length needs to be less than or equal to capacity.
The first length values must be properly initialized values of type T.
capacity needs to [fit] the layout size that the pointer was allocated with.
The allocated size in bytes must be no larger than isize::MAX. See the safety documentation of pointer::offset.
These requirements are always upheld by any ptr that has been allocated via Vec<T, A>. Other allocation sources are allowed if the invariants are upheld.
Violating these may cause problems like corrupting the allocator's internal data structures. For example it is not safe to build a Vec<u8> from a pointer to a C char array with length size_t. It's also not safe to build one from a Vec<u16> and its length, because the allocator cares about the alignment, and these two types have different alignments. The buffer was allocated with alignment 2 (for u16), but after turning it into a Vec<u8> it'll be deallocated with alignment 1.
The ownership of ptr is effectively transferred to the Vec<T> which may then deallocate, reallocate or change the contents of memory pointed to by the pointer at will. Ensure that nothing else uses the pointer after calling this function.
This is highly unsafe, due to the number of invariants that aren't checked:
If T is not a zero-sized type and the capacity is nonzero, ptr must have been allocated using the global allocator, such as via the alloc::alloc function. If T is a zero-sized type or the capacity is zero, ptr need only be non-null and aligned.
T needs to have the same alignment as what ptr was allocated with, if the pointer is required to be allocated. (T having a less strict alignment is not sufficient, the alignment really needs to be equal to satisfy the dealloc requirement that memory must be allocated and deallocated with the same layout.)
The size of T times the capacity (i.e. the allocated size in bytes), if nonzero, needs to be the same size as the pointer was allocated with. (Because similar to alignment, dealloc must be called with the same layout size.)
length needs to be less than or equal to capacity.
The first length values must be properly initialized values of type T.
capacity needs to be the capacity that the pointer was allocated with, if the pointer is required to be allocated.
The allocated size in bytes must be no larger than isize::MAX. See the safety documentation of pointer::offset.
These requirements are always upheld by any ptr that has been allocated via Vec<T>. Other allocation sources are allowed if the invariants are upheld.
Violating these may cause problems like corrupting the allocator's internal data structures. For example it is normally not safe to build a Vec<u8> from a pointer to a C char array with length size_t, doing so is only safe if the array was initially allocated by a Vec or String. It's also not safe to build one from a Vec<u16> and its length, because the allocator cares about the alignment, and these two types have different alignments. The buffer was allocated with alignment 2 (for u16), but after turning it into a Vec<u8> it'll be deallocated with alignment 1. To avoid these issues, it is often preferable to do casting/transmuting using slice::from_raw_parts instead.
The ownership of ptr is effectively transferred to the Vec<T> which may then deallocate, reallocate or change the contents of memory pointed to by the pointer at will. Ensure that nothing else uses the pointer after calling this function.
This is highly unsafe, due to the number of invariants that aren't checked:
ptr must be [currently allocated] via the given allocator alloc.
T needs to have the same alignment as what ptr was allocated with. (T having a less strict alignment is not sufficient, the alignment really needs to be equal to satisfy the dealloc requirement that memory must be allocated and deallocated with the same layout.)
The size of T times the capacity (i.e. the allocated size in bytes) needs to be the same size as the pointer was allocated with. (Because similar to alignment, dealloc must be called with the same layout size.)
length needs to be less than or equal to capacity.
The first length values must be properly initialized values of type T.
capacity needs to [fit] the layout size that the pointer was allocated with.
The allocated size in bytes must be no larger than isize::MAX. See the safety documentation of pointer::offset.
These requirements are always upheld by any ptr that has been allocated via Vec<T, A>. Other allocation sources are allowed if the invariants are upheld.
Violating these may cause problems like corrupting the allocator's internal data structures. For example it is not safe to build a Vec<u8> from a pointer to a C char array with length size_t. It's also not safe to build one from a Vec<u16> and its length, because the allocator cares about the alignment, and these two types have different alignments. The buffer was allocated with alignment 2 (for u16), but after turning it into a Vec<u8> it'll be deallocated with alignment 1.
The ownership of ptr is effectively transferred to the Vec<T> which may then deallocate, reallocate or change the contents of memory pointed to by the pointer at will. Ensure that nothing else uses the pointer after calling this function.
Implementors of Allocator must ensure that a memory block that is [currently allocated] by the allocator points to valid memory, until that memory block is [invalidated]. The implementor must also not violate this invariant of Allocator via allocator equivalences that are in the implementor's control (e.g., via a misbehaving impl Clone for Box<MyAllocator>).
Additionally, any memory block returned by the allocator must satisfy the allocation invariants described in core::ptr. In particular, if a block has base address p and size n, then p as usize + n <= usize::MAX must hold.
This ensures that pointer arithmetic within the allocation (for example, ptr.add(len)) cannot overflow the address space.
The GlobalAlloc trait is an unsafe trait for a number of reasons, and implementors must ensure that they adhere to these contracts:
It is undefined behavior for the allocator to read, write, or deallocate any memory that is currently allocated. This memory is owned by the user, the allocator must not touch it.
It's undefined behavior if global allocators unwind. This restriction may be lifted in the future, but currently a panic from any of these functions may lead to memory unsafety.
Callers of this trait are allowed to rely on the contracts defined on each method, and implementors must ensure such contracts remain true.
In addition to the safety requirements of Allocator, global allocators are subject to some additional constraints:
It's undefined behavior if global allocators unwind. This restriction may be lifted in the future, but currently a panic from any of these functions may lead to memory unsafety.
You must not rely on allocations actually happening, even if there are explicit heap allocations in the source. The optimizer may detect unused allocations that it can either eliminate entirely or move to the stack and thus never invoke the allocator. The optimizer may further assume that allocation is infallible, so code that used to fail due to allocator failures may now suddenly work because the optimizer worked around the need for an allocation. More concretely, the following code example is unsound, irrespective of whether your custom allocator allows counting how many allocations have happened.
``rust,ignore (unsound and has placeholders) drop(Box::new(42)); let number_of_heap_allocs = / call private allocator API /; unsafe { std::hint::assert_unchecked(number_of_heap_allocs > 0); } ``
Note that the optimizations mentioned above are not the only optimization that can be applied. You may generally not rely on heap allocations happening if they can be removed without changing program behavior. Whether allocations happen or not is not part of the program behavior, even if it could be detected via an allocator that tracks allocations by printing or otherwise having side effects.
layout must have non-zero size. Attempting to allocate for a zero-sized layout will result in undefined behavior.
(Extension subtraits might provide more specific bounds on behavior, e.g., guarantee a sentinel address or a null pointer in response to a zero-size allocation request.)
The allocated block of memory may or may not be initialized.
The caller has to ensure that layout has non-zero size. Like alloc zero sized layout will result in undefined behavior. However the allocated block of memory is guaranteed to be initialized.
layout is the same layout that was used to allocate that block of memory,
new_size is greater than zero.
new_size, when rounded up to the nearest multiple of layout.align(), does not overflow isize (i.e., the rounded value must be less than or equal to isize::MAX).
If these are not followed, the behavior is undefined.
(Extension subtraits might provide more specific bounds on behavior, e.g., guarantee a sentinel address or a null pointer in response to a zero-size allocation request.)
This function is safe to call if the pointer is safe to reborrow as &T (in which case you could also call for_value[Self::for_value]). Otherwise, the following conditions must hold:
If T is Sized, this function is always safe to call.
If the unsized tail of T is:
a [slice] [U], str, or a [trait object] dyn Trait, then 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.
No other kind of unsized tail currently exists that satisfies the trait bounds for this function. If more kinds of unsized tails get introduced in the future, the documentation of this function will have to be extended before it can be used for such types.
Here, unsized tail refers to the type obtained by recursively descending through the last field of a tuple or struct until we arrived at a built-in unsized type.
As a consequence of these rules, it is the case that whenever it is allowed to convert val into a shared reference, then it is also allowed to invoke this function.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
If d >= 10 and d <= 64, this is allowed to return any value or panic. Notably, it should not be expected to return hex digits, or any other reasonable extension of the decimal digits.
(This loose safety condition is intended to simplify soundness proofs when writing code using this method, since the implementation doesn't need something really specific, not to make those other arguments do something useful. It might be tightened before stabilization.)
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
Unlike RefCell::borrow, this method is unsafe because it does not return a Ref, thus leaving the borrow flag untouched. Mutably borrowing the RefCell while the reference returned by this method is alive is undefined behavior.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
Implementations must ensure that when .clone_to_uninit(dest) returns normally rather than panicking, it always leaves *dest initialized as a valid value of type Self.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and first-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg, the first-fault register (FFR) and non-faulting behaviour).
Result lanes corresponding to inactive FFR lanes (either before or as a result of this intrinsic) have "CONSTRAINED UNPREDICTABLE" values, irrespective of predication. Refer to architectural documentation for details.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg).
This dereferences and accesses the calculated address for each active element (governed by pg).
Addresses passed in bases lack provenance, so this is similar to using a usize as ptr cast (or core::ptr::with_exposed_provenance) on each lane before using it.
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
pointer::offset(pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by pg). In particular, note that vnum is scaled by the vector length, VL, which is not known at compile time.
This dereferences and accesses the calculated address for each active element (governed by pg).
After using this intrinsic, but before any other access to the memory that this intrinsic mutates, a call to _mm_sfence must be performed by the thread that used the intrinsic. In particular, functions that call this intrinsic should generally call _mm_sfence before they return.
After using this intrinsic, but before any other access to the memory that this intrinsic mutates, a call to _mm_sfence must be performed by the thread that used the intrinsic. In particular, functions that call this intrinsic should generally call _mm_sfence before they return.
After using this intrinsic, but before any other access to the memory that this intrinsic mutates, a call to _mm_sfence must be performed by the thread that used the intrinsic. In particular, functions that call this intrinsic should generally call _mm_sfence before they return.
After using this intrinsic, but before any other access to the memory that this intrinsic mutates, a call to _mm_sfence must be performed by the thread that used the intrinsic. In particular, functions that call this intrinsic should generally call _mm_sfence before they return.
After using this intrinsic, but before any other access to the memory that this intrinsic mutates, a call to _mm_sfence must be performed by the thread that used the intrinsic. In particular, functions that call this intrinsic should generally call _mm_sfence before they return.
After using this intrinsic, but before any other access to the memory that this intrinsic mutates, a call to _mm_sfence must be performed by the thread that used the intrinsic. In particular, functions that call this intrinsic should generally call _mm_sfence before they return.
Unlike the prefetch intrinsics, CLFLUSHOPT is subject to all the permission checking and faults associated with a byte load, so p must point to a byte that is valid for reads.
After using this intrinsic, but before any other access to the memory that this intrinsic mutates, a call to _mm_sfence must be performed by the thread that used the intrinsic. In particular, functions that call this intrinsic should generally call _mm_sfence before they return.
Unlike the prefetch intrinsics, CLFLUSH is subject to all the permission checking and faults associated with a byte load, so p must point to a byte that is valid for reads.
After using this intrinsic, but before any other access to the memory that this intrinsic mutates, a call to _mm_sfence must be performed by the thread that used the intrinsic. In particular, functions that call this intrinsic should generally call _mm_sfence before they return.
After using this intrinsic, but before any other access to the memory that this intrinsic mutates, a call to _mm_sfence must be performed by the thread that used the intrinsic. In particular, functions that call this intrinsic should generally call _mm_sfence before they return.
After using this intrinsic, but before any other access to the memory that this intrinsic mutates, a call to _mm_sfence must be performed by the thread that used the intrinsic. In particular, functions that call this intrinsic should generally call _mm_sfence before they return.
After using this intrinsic, but before any other access to the memory that this intrinsic mutates, a call to _mm_sfence must be performed by the thread that used the intrinsic. In particular, functions that call this intrinsic should generally call _mm_sfence before they return.
After using this intrinsic, but before any other access to the memory that this intrinsic mutates, a call to _mm_sfence must be performed by the thread that used the intrinsic. In particular, functions that call this intrinsic should generally call _mm_sfence before they return.
After using this intrinsic, but before any other access to the memory that this intrinsic mutates, a call to _mm_sfence must be performed by the thread that used the intrinsic. In particular, functions that call this intrinsic should generally call _mm_sfence before they return.
After using this intrinsic, but before any other access to the memory that this intrinsic mutates, a call to _mm_sfence must be performed by the thread that used the intrinsic. In particular, functions that call this intrinsic should generally call _mm_sfence before they return.
This trait, when implemented, asserts the compiler can monomorphize #[repr(simd)] structs with the marked type as an element. Strictly, it is valid to impl if the vector will not be miscompiled. Practically, it is user-unfriendly to impl it if the vector won't compile, even when no soundness guarantees are broken by allowing the user to try.
When C passes variable arguments, signed integers smaller than c_int are promoted to c_int, unsigned integers smaller than c_uint are promoted to c_uint, and c_float is promoted to c_double. Implementing this trait for types that are subject to this promotion rule is invalid.
This trait is only implemented for 128-bit integers when the platform defines the __int128 type.
The memory pointed to by ptr must contain a valid nul terminator at the end of the string.
ptr must be [valid] for reads of bytes up to and including the nul terminator. This means in particular:
The entire memory range of this CStr must be contained within a single allocation!
ptr must be non-null even for a zero-length cstr.
The memory referenced by the returned CStr must not be mutated for the duration of lifetime 'a.
The nul terminator must be within isize::MAX from ptr
> Note: This operation is intended to be a 0-cost cast but it is > currently implemented with an up-front calculation of the length of > the string. This is not guaranteed to always be the case.
This function is safe to call only if all of the following conditions are satisfied:
There is another c-variadic argument to read.
The actual type of the argument U is compatible with T (as defined below).
If U and T are both integer types, then the value passed by the caller must be representable in both types.
If T is not Copy, then it must not have already been read using next_arg on a clone[VaList::clone]d copy of this VaList. (Currently, all types implementing VaArgSafe also implement Copy, but this may change in the future.)
Types T and U are compatible when:
T and U are the same type.
T and U are integer types of the same size.
T and U are both pointers, and their target types are compatible.
T is a pointer to c_void and U is a pointer to i8 or u8, or vice versa.
The pointer _to_drop must be valid for both reads and writes, not only for the duration of this function call, but also until the returned future has completed. See [ptr::drop_in_place] for additional safety concerns.
As the compiler assumes that all forms of Undefined Behavior can never happen, it will eliminate all branches in the surrounding code that it can determine will invariably lead to a call to unreachable_unchecked().
If the assumptions embedded in using this function turn out to be wrong - that is, if the site which is calling unreachable_unchecked() is actually reachable at runtime - the compiler may have generated nonsensical machine instructions for this situation, including in seemingly unrelated code, causing difficult-to-debug problems.
Use this function sparingly. Consider using the unreachable! macro, which may prevent some optimizations but will safely panic in case it is actually reached at runtime. Benchmark your code to find out if using unreachable_unchecked() comes with a performance benefit.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
This results in undefined behavior when rhs == 0, self % rhs != 0, or self == i128::MIN && rhs == -1, i.e. when checked_div_exact(Self::checked_div_exact) would return None.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
This results in undefined behavior when rhs == 0, self % rhs != 0, or self == i16::MIN && rhs == -1, i.e. when checked_div_exact(Self::checked_div_exact) would return None.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
This results in undefined behavior when rhs == 0, self % rhs != 0, or self == i32::MIN && rhs == -1, i.e. when checked_div_exact(Self::checked_div_exact) would return None.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
This results in undefined behavior when rhs == 0, self % rhs != 0, or self == i64::MIN && rhs == -1, i.e. when checked_div_exact(Self::checked_div_exact) would return None.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
This results in undefined behavior when rhs == 0, self % rhs != 0, or self == i8::MIN && rhs == -1, i.e. when checked_div_exact(Self::checked_div_exact) would return None.
Unlike the offset intrinsic, this intrinsic does not restrict the resulting pointer to point into or at the end of an allocated object, and it wraps with two's complement arithmetic. The resulting value is not necessarily valid to be used to actually access memory.
The stabilized version of this intrinsic is pointer::wrapping_offset.
If the computed offset is non-zero, then both the starting and resulting pointer must be either in bounds or at the end of an allocation. If either pointer is out of bounds or arithmetic overflow occurs then this operation is undefined behavior.
The stabilized version of this intrinsic is pointer::offset.
It's UB to call this if any of the bytes in a or b are uninitialized. Note that this is a stricter criterion than just the values being fully-initialized: if T has padding, it's UB to call this intrinsic.
At compile-time, it is furthermore UB to call this if any of the bytes in a or b have provenance.
(The implementation is allowed to branch on the results of comparisons, which is UB if any of their inputs are undef.)
The safety requirements are consistent with copy_nonoverlapping while the read and write behaviors are volatile, which means it will not be optimized out unless _count or size_of::<T>() is equal to zero.
The safety requirements are consistent with write_bytes while the write behavior is volatile, which means it will not be optimized out unless _count or size_of::<T>() is equal to zero.
Casting from integer types is always safe. Casting between two float types is also always safe.
Casting floats to integers truncates, following the same rules as to_int_unchecked. Specifically, each element must: Not be NaN Not be infinite * Be representable in the return type, after truncating off its fractional part
Each pointer in ptr whose corresponding value in mask is !0 must be writable as if by ptr::write[crate::ptr::write] (e.g. aligned to the element type).
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
This results in undefined behavior when rhs == 0, self % rhs != 0, or self == isize::MIN && rhs == -1, i.e. when checked_div_exact(Self::checked_div_exact) would return None.
The implementation of Step for the given type must guarantee all invariants of all methods are upheld. See the Step trait's documentation for details. Consumers are free to rely on the invariants in unsafe code.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
If Dst: TransmuteFrom<Src, ASSUMPTIONS>, the compiler guarantees that Src is soundly union-transmutable into a value of type Dst, provided that the programmer has guaranteed that the given ASSUMPTIONS(Assume) are satisfied.
A union-transmute is any bit-reinterpretation conversion in the form of:
#[repr(C)] union Transmute<Src, Dst> { src: ManuallyDrop<Src>, dst: ManuallyDrop<Dst>, }
let transmute = Transmute { src: ManuallyDrop::new(src), };
let dst = unsafe { transmute.dst };
ManuallyDrop::into_inner(dst) } ```
Note that this construction is more permissive than mem::transmute_copy(super::transmute_copy); union-transmutes permit conversions that extend the bits of Src with trailing padding to fill trailing uninitialized bytes of Self; e.g.:
This function is safe to call if the pointer is safe to reborrow as &T (in which case you could also call align_of_val). Otherwise, the following conditions must hold:
If T is Sized, this function is always safe to call.
If the unsized tail of T is:
a [slice] [U], str, or a [trait object] dyn Trait, then 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.
No other kind of unsized tail currently exists that satisfies the trait bounds for this function. If more kinds of unsized tails get introduced in the future, the documentation of this function will have to be extended before it can be used for such types.
Here, unsized tail refers to the type obtained by recursively descending through the last field of a tuple or struct until we arrived at a built-in unsized type.
As a consequence of these rules, it is the case that whenever it is allowed to convert val into a shared reference, then it is also allowed to invoke this function.
T must be [inhabited], i.e. possible to construct. This means that types like zero-variant enums and ! are unsound to conjure.
You must use the value only in ways which do not violate any safety invariants of the type.
While it's easy to create a valid instance of an inhabited ZST, since having no bits in its representation means there's only one possible value, that doesn't mean that it's always sound to do so.
For example, a library could design zero-sized tokens that are !Default + !Clone, limiting their creation to functions that initialize some state or establish a scope. Conjuring such a token could break invariants and lead to unsoundness.
This function is safe to call if the pointer is safe to reborrow as &T (in which case you could also call size_of_val). Otherwise, the following conditions must hold:
If T is Sized, this function is always safe to call.
If the unsized tail of T is:
a [slice] [U], str, or a [trait object] dyn Trait, then 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.
No other kind of unsized tail currently exists that satisfies the trait bounds for this function. If more kinds of unsized tails get introduced in the future, the documentation of this function will have to be extended before it can be used for such types.
Here, unsized tail refers to the type obtained by recursively descending through the last field of a tuple or struct until we arrived at a built-in unsized type.
As a consequence of these rules, it is the case that whenever it is allowed to convert val into a shared reference, then it is also allowed to invoke this function.
The safety obligations of the caller depend on the value of ASSUME: - If ASSUME.alignment(Assume::alignment), the caller must guarantee that the addresses of references in the returned Self satisfy the alignment requirements of their referent types. - If ASSUME.lifetimes(Assume::lifetimes), the caller must guarantee that references in the returned Self will not outlive their referents. - If ASSUME.safety(Assume::safety), the returned value might not satisfy the library safety invariants of Self, and the caller must guarantee that undefined behavior does not arise from uses of the returned value. - If ASSUME.validity(Assume::validity), the caller must guarantee that src is a bit-valid instance of Self.
When satisfying the above obligations (if any), the caller must not assume that this trait provides any inherent guarantee of layout portability or stability.
The first size_of::<Dst>() bytes behind src must be readable
The first size_of::<Dst>() bytes behind src must be [valid] when interpreted as a Dst.
On top of that, remember that most types have additional invariants beyond merely being considered initialized at the type level. For example, a 1-initialized Vec<T> is considered initialized (under the current implementation; this does not constitute a stable guarantee) because the only requirement the compiler knows about it is that the data pointer must be non-null. Creating such a Vec<T> does not cause immediate undefined behavior, but will cause undefined behavior with most safe operations (including dropping it).
If size_of::<Src>() >= size_of::<Dst>(), the first size_of::<Dst>() bytes of src must be be valid when interpreted as a Dst. (In this case, the preconditions are the same as for transmute_copy(&ManuallyDrop::new(src)).)
If size_of::<Src>() <= size_of::<Dst>(), the bytes of src padded with uninitialized bytes afterwards up to a total size of size_of::<Dst>() must be valid when interpreted as a Dst.
In both cases, any safety preconditions of the Dst type must also be upheld.
This function is safe to call if the pointer is safe to reborrow as &T (in which case you could also call of_val[Self::of_val]). Otherwise, the following conditions must hold:
If T is Sized, this function is always safe to call.
If the unsized tail of T is:
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) must fit in isize.
an (unstable) [extern type], then this function is always safe to call, but may panic or otherwise return the wrong value, as the extern type's layout is not known. This is the same behavior as Alignment::of_val on a reference to a type with an extern type tail.
otherwise, it is conservatively not allowed to call this function.
This function runs the destructor of the contained value. Other than changes made by the destructor itself, the memory is left unchanged, and so as far as the compiler is concerned still holds a bit-pattern which is valid for the type T.
However, this "zombie" value should not be exposed to safe code, and this function should not be called more than once. To use a value after it's been dropped, or drop a value multiple times, can cause Undefined Behavior (depending on what drop does). This is normally prevented by the type system, but users of ManuallyDrop must uphold those guarantees without assistance from the compiler.
This function semantically moves out the contained value without preventing further usage, leaving the state of this container unchanged. It is your responsibility to ensure that this ManuallyDrop is not used again.
It is up to the caller to guarantee that the MaybeUninit<T> really is in an initialized state, i.e., a state that is considered ["valid" for type T][validity]. Calling this when the content is not yet fully initialized causes immediate undefined behavior. The [type-level documentation][inv] contains more information about this initialization invariant.
It is a common mistake to assume that this function is safe to call on integers because they can hold all bit patterns. It is also a common mistake to think that calling this function is UB if any byte is uninitialized. Both of these assumptions are wrong. If that is surprising to you, please read the [type-level documentation][inv].
On top of that, remember that most types have additional invariants beyond merely being considered initialized at the type level. For example, a 1-initialized Vec<T> is considered initialized (under the current implementation; this does not constitute a stable guarantee) because the only requirement the compiler knows about it is that the data pointer must be non-null. Creating such a Vec<T> does not cause immediate undefined behavior, but will cause undefined behavior with most safe operations (including dropping it).
It is up to the caller to guarantee that the MaybeUninit<T> really is in an initialized state. Calling this when the content is not yet fully initialized causes undefined behavior.
On top of that, all additional invariants of the type T must be satisfied, as the Drop implementation of T (or its members) may rely on this. For example, setting a Vec<T> to an invalid but non-null address makes it initialized (under the current implementation; this does not constitute a stable guarantee), because the only requirement the compiler knows about it is that the data pointer must be non-null. Dropping such a Vec<T> however will cause undefined behavior.
Calling this when the content is not yet fully initialized causes undefined behavior: it is up to the caller to guarantee that the MaybeUninit<T> really is in an initialized state. For instance, .assume_init_mut() cannot be used to initialize a MaybeUninit.
It is up to the caller to guarantee that the MaybeUninit<T> really is in an initialized state. Calling this when the content is not yet fully initialized causes undefined behavior. The [type-level documentation][inv] contains more information about this initialization invariant.
Moreover, similar to the ptr::read function, this function creates a bitwise copy of the contents, regardless whether the contained type implements the Copy trait or not. When using multiple copies of the data (by calling assume_init_read multiple times, or first calling assume_init_read and then assume_init), it is your responsibility to ensure that data may indeed be duplicated.
Calling this when the content is not yet fully initialized causes undefined behavior: it is up to the caller to guarantee that the MaybeUninit<T> really is in an initialized state.
The safety obligations of the caller depend on the value of ASSUME: - If ASSUME.alignment(Assume::alignment), the caller must guarantee that the addresses of references in the returned Self satisfy the alignment requirements of their referent types. - If ASSUME.lifetimes(Assume::lifetimes), the caller must guarantee that references in the returned Self will not outlive their referents. - If ASSUME.safety(Assume::safety), the returned value might not satisfy the library safety invariants of Self, and the caller must guarantee that undefined behavior does not arise from uses of the returned value. - If ASSUME.validity(Assume::validity), the caller must guarantee that src is a bit-valid instance of Self.
When satisfying the above obligations (if any), the caller must not assume that this trait provides any inherent guarantee of layout portability or stability.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
Types implementing this trait must be primitives that are valid when zeroed.
The associated Self::NonZeroInner type must have the same size+align as Self, but with a niche and bit validity making it so the following transmutes are sound:
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
Given a pointer of this type, the concrete type returned by its deref method and (if it implements DerefMut) its deref_mut method must be the same type and must not change without a modification. The following operations are not considered modifications:
Moving the pointer.
Performing unsizing coercions on the pointer.
Performing dynamic dispatch with the pointer.
Calling deref or deref_mut on the pointer.
The concrete type of a trait object is the type that the vtable corresponds to. The concrete type of a slice is an array of the same element type and the length specified in the metadata. The concrete type of a sized type is the type itself.
This function is unsafe. You must guarantee that you will never move the data out of the mutable reference you receive when you call this function, so that the invariants on the Pin type can be upheld.
If the underlying data is Unpin, Pin::get_mut should be used instead.
This function is unsafe. You must guarantee that you will continue to treat the pointer Ptr as pinned after you call this function, so that the invariants on the Pin type can be upheld. If the code using the resulting Ptr does not continue to maintain the pinning invariants that is a violation of the API contract and may lead to undefined behavior in later (safe) operations.
Note that you must be able to guarantee that the data pointed to by Ptr will be treated as pinned all the way until its drop handler is complete!
For more information, see the [pin module docs][self]
If the underlying data is Unpin, Pin::into_inner should be used instead.
This function is unsafe. You must guarantee that the data you return will not move so long as the argument value does not move (for example, because it is one of the fields of that value), and also that you do not move out of the argument you receive to the interior function.
This function is unsafe. You must guarantee that the data you return will not move so long as the argument value does not move (for example, because it is one of the fields of that value), and also that you do not move out of the argument you receive to the interior function.
This constructor is unsafe because we cannot guarantee that the data pointed to by pointer is pinned. At its core, pinning a value means making the guarantee that the value's data will not be moved nor have its storage invalidated until it gets dropped. For a more thorough explanation of pinning, see the [pin module docs].
If the caller that is constructing this Pin<Ptr> does not ensure that the data Ptr points to is pinned, that is a violation of the API contract and may lead to undefined behavior in later (even safe) operations.
By using this method, you are also making a promise about the Deref, DerefMut, and Drop implementations of Ptr, if they exist. Most importantly, they must not move out of their self arguments: Pin::as_mut and Pin::as_ref will call DerefMut::deref_mut and Deref::derefon the pointer type Ptr and expect these methods to uphold the pinning invariants. Moreover, by calling this method you promise that the reference Ptr dereferences to will not be moved out of again; in particular, it must not be possible to obtain a &mut Ptr::Target and then move out of that reference (using, for example mem::swap).
For example, calling Pin::new_unchecked on an &'a mut T is unsafe because while you are able to pin it for the given lifetime 'a, you have no control over whether it is kept pinned once 'a ends, and therefore cannot uphold the guarantee that a value, once pinned, remains pinned until it is dropped:
``` use std::mem; use std::pin::Pin;
fn move_pinned_ref<T>(mut a: T, mut b: T) { unsafe { let p: Pin<&mut T> = Pin::new_unchecked(&mut a); // This should mean the pointee a can never move again. } mem::swap(&mut a, &mut b); // Potential UB down the road ⚠️ // The address of a changed to b's stack slot, so a got moved even // though we have previously pinned it! We have violated the pinning API contract. } `` A value, once pinned, must remain pinned until it is dropped (unless its type implements Unpin). Because Pin<&mut T> does not own the value, dropping the Pin will not drop the value and will not end the pinning contract. So moving the value after dropping the Pin<&mut T>` is still a violation of the API contract.
Similarly, calling Pin::new_unchecked on an Rc<T> is unsafe because there could be aliases to the same data that are not subject to the pinning restrictions: ``` use std::rc::Rc; use std::pin::Pin;
fn move_pinned_rc<T>(mut x: Rc<T>) { // This should mean the pointee can never move again. let pin = unsafe { Pin::new_unchecked(Rc::clone(&x)) }; { let p: Pin<&T> = pin.as_ref(); // ... } drop(pin);
let content = Rc::get_mut(&mut x).unwrap(); // Potential UB down the road ⚠️ // Now, if x was the only reference, we have a mutable reference to // data that we pinned above, which we could use to move it as we have // seen in the previous example. We have violated the pinning API contract. } ```
If any of the following conditions are violated, the result is Undefined Behavior:
The offset in bytes, count * size_of::<T>(), computed on mathematical integers (without "wrapping around"), must fit in an isize.
Let result be self.addr() + count * size_of::<T>(), computed on mathematical integers. This must fit in a usize.
If the computed offset is non-zero, then self must be [derived from][crate::ptr#provenance] a pointer to some [allocation], and the entire memory range between self and result (i.e., self.addr()..result) must be in bounds of that allocation.
Allocations can never be larger than isize::MAX bytes and they can only contain addresses representable by usize, so technically the last condition implies the first two. This implies, for instance, that vec.as_ptr().add(vec.len()) (for vec: Vec<T>) is always safe.
Consider using wrapping_add(#method.wrapping_add) instead if these constraints are difficult to satisfy. The only advantage of this method is that it enables more aggressive compiler optimizations.
When calling this method, you have to ensure that either the pointer is null or the pointer is convertible to a reference. Note that because the created reference is to MaybeUninit<T>, the source pointer can point to uninitialized memory.
When calling this method, you have to ensure that either the pointer is null or the pointer is convertible to a reference. Note that because the created reference is to MaybeUninit<T>, the source pointer can point to uninitialized memory.
When calling this method, you have to ensure that either the pointer is null or all of the following are true:
The pointer must be [valid] for reads for ptr.len() * size_of::<T>() many bytes, and it must be properly aligned. This means in particular:
The entire memory range of this slice must be contained within a single [allocation]! Slices can never span across multiple allocations.
The pointer must be aligned even for zero-length slices. One reason for this is that enum layout optimizations may rely on references (including slices of any length) being aligned and non-null to distinguish them from other data. You can obtain a pointer that is usable as data for zero-length slices using NonNull::dangling().
The total size ptr.len() * size_of::<T>() of the slice must be no larger than isize::MAX. See the safety documentation of pointer::offset.
You must enforce Rust's aliasing rules, since the returned lifetime 'a is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, while this reference exists, the memory the pointer points to must not get mutated (except inside UnsafeCell).
This applies even if the result of this method is unused!
When calling this method, you have to ensure that either the pointer is null or all of the following is true:
The pointer must be [valid] for reads and writes for ptr.len() * size_of::<T>() many bytes, and it must be properly aligned. This means in particular:
The entire memory range of this slice must be contained within a single [allocation]! Slices can never span across multiple allocations.
The pointer must be aligned even for zero-length slices. One reason for this is that enum layout optimizations may rely on references (including slices of any length) being aligned and non-null to distinguish them from other data. You can obtain a pointer that is usable as data for zero-length slices using NonNull::dangling().
The total size ptr.len() * size_of::<T>() of the slice must be no larger than isize::MAX. See the safety documentation of pointer::offset.
You must enforce Rust's aliasing rules, since the returned lifetime 'a is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, while this reference exists, the memory the pointer points to must not get accessed (read or written) through any other pointer.
This applies even if the result of this method is unused!
If any of the following conditions are violated, the result is Undefined Behavior:
The offset in bytes, count * size_of::<T>(), computed on mathematical integers (without "wrapping around"), must fit in an isize.
Let result be self.addr() + count * size_of::<T>(), computed on mathematical integers. This must fit in a usize.
If the computed offset is non-zero, then self must be [derived from][crate::ptr#provenance] a pointer to some [allocation], and the entire memory range between self and result (i.e., min(self.addr(), result)..max(self.addr(), result)) must be in bounds of that allocation.
Allocations can never be larger than isize::MAX bytes and they can only contain addresses representable by usize, so technically the last condition implies the first two. This implies, for instance, that vec.as_ptr().offset(vec.len() as isize) (for vec: Vec<T>) is always safe.
Consider using wrapping_offset(#method.wrapping_offset) instead if these constraints are difficult to satisfy. The only advantage of this method is that it enables more aggressive compiler optimizations.
If any of the following conditions are violated, the result is Undefined Behavior:
self and origin must either
point to the same address, or
both be [derived from][crate::ptr#provenance] a pointer to the same [allocation], and the memory range between the two pointers must be in bounds of that object. (See below for an example.)
The distance between the pointers, in bytes, must be an exact multiple of the size of T.
As a consequence, the absolute distance between the pointers, in bytes, computed on mathematical integers (without "wrapping around"), cannot overflow an isize. This is implied by the in-bounds requirement, and the fact that no allocation can be larger than isize::MAX bytes.
The requirement for pointers to be derived from the same allocation is primarily needed for const-compatibility: the distance between pointers into different allocated objects is not known at compile-time. However, the requirement also exists at runtime and may be exploited by optimizations. If you wish to compute the difference between pointers that are not guaranteed to be from the same allocation, use (self.addr() as isize - origin.addr() as isize) / size_of::<T>().
The distance between the pointers must be non-negative (self >= origin)
All the safety conditions of offset_from(#method.offset_from) apply to this method as well; see it for the full details.
Importantly, despite the return type of this method being able to represent a larger offset, it's still not permitted to pass pointers which differ by more than isize::MAXbytes. As such, the result of this method will always be less than or equal to isize::MAX as usize.
mid must be [in-bounds] of the underlying [allocation]. Which means self must be dereferenceable and span a single allocation that is at least mid size_of::<T>() bytes long. Not upholding these requirements is [undefined behavior]* even if the resulting pointers are not used.
Since len being in-bounds is not a safety invariant of *mut [T] the safety requirements of this method are the same as for split_at_mut_unchecked. The explicit bounds check is only as useful as len is correct.
mid must be [in-bounds] of the underlying [allocation]. Which means self must be dereferenceable and span a single allocation that is at least mid size_of::<T>() bytes long. Not upholding these requirements is [undefined behavior]* even if the resulting pointers are not used.
If any of the following conditions are violated, the result is Undefined Behavior:
The offset in bytes, count * size_of::<T>(), computed on mathematical integers (without "wrapping around"), must fit in an isize.
Let result be self.addr() - count * size_of::<T>(), computed on mathematical integers. This must fit in a usize.
If the computed offset is non-zero, then self must be [derived from][crate::ptr#provenance] a pointer to some [allocation], and the entire memory range between self and result (i.e., result..self.addr()) must be in bounds of that allocation.
Allocations can never be larger than isize::MAX bytes and they can only contain addresses representable by usize, so technically the last condition implies the first two.
Consider using wrapping_sub(#method.wrapping_sub) instead if these constraints are difficult to satisfy. The only advantage of this method is that it enables more aggressive compiler optimizations.
Behavior is undefined if any of the following conditions are violated:
src must be [valid] for reads of count * size_of::<T>() bytes or that number must be 0.
dst must be [valid] for writes of count size_of::<T>() bytes or that number must be 0, and dst must remain valid even when src is read for count size_of::<T>() bytes. (This means if the memory ranges overlap, the dst pointer must not be invalidated by src reads.)
Both src and dst must be properly aligned.
Like read, copy creates a bitwise copy of T, regardless of whether T is Copy. If T is not Copy, using both the values in the region beginning at src and the region beginning at dst can [violate memory safety][read-ownership].
Note that even if the effectively copied size (count * size_of::<T>()) is 0, the pointers must be properly aligned.
Behavior is undefined if any of the following conditions are violated:
src must be [valid] for reads of count * size_of::<T>() bytes or that number must be 0.
dst must be [valid] for writes of count * size_of::<T>() bytes or that number must be 0.
Both src and dst must be properly aligned.
The region of memory beginning at src with a size of count size_of::<T>() bytes must not* overlap with the region of memory beginning at dst with the same size.
Like read, copy_nonoverlapping creates a bitwise copy of T, regardless of whether T is Copy. If T is not Copy, using both the values in the region beginning at src and the region beginning at dst can [violate memory safety][read-ownership].
Note that even if the effectively copied size (count * size_of::<T>()) is 0, the pointers must be properly aligned.
Behavior is undefined if any of the following conditions are violated:
to_drop must be [valid] for both reads and writes.
to_drop must be properly aligned, even if T has size 0.
to_drop must be nonnull, even if T has size 0.
The value to_drop points to must be valid for dropping, which may mean it must uphold additional invariants. These invariants depend on the type of the value being dropped. For instance, when dropping a Box, the box's pointer to the heap must be valid.
While drop_in_place is executing, the only way to access parts of to_drop is through the &mut self references supplied to the Drop::drop methods that drop_in_place invokes.
Additionally, if T is not Copy, using the pointed-to value after calling drop_in_place can cause undefined behavior. Note that *to_drop = foo counts as a use because it will cause the value to be dropped again. write() can be used to overwrite data without causing it to be dropped.
Behavior is undefined if any of the following conditions are violated:
src must be [valid] for reads.
src must point to a properly initialized value of type T.
Like read, read_unaligned creates a bitwise copy of T, regardless of whether T is Copy. If T is not Copy, using both the returned value and the value at *src can [violate memory safety][read-ownership].
Like read, read_volatile creates a bitwise copy of T, regardless of whether T is Copy. If T is not Copy, using both the returned value and the value at *src can [violate memory safety][read-ownership]. However, storing non-Copy types in volatile memory is almost certainly incorrect.
Behavior is undefined if any of the following conditions are violated:
src must be either [valid] for reads, or T must be a ZST, or src must point to memory outside of all Rust allocations and reading from that memory must:
not trap, and
not cause any memory inside a Rust allocation to be modified.
src must be properly aligned.
Reading from src must produce a properly initialized value of type T.
Note that even if T has size 0, the pointer must be properly aligned.
Behavior is undefined if any of the following conditions are violated:
Both x and y must be [valid] for both reads and writes. They must remain valid even when the other pointer is written. (This means if the memory ranges overlap, the two pointers must not be subject to aliasing restrictions relative to each other.)
Both x and y must be properly aligned.
Note that even if T has size 0, the pointers must be properly aligned.
Behavior is undefined if any of the following conditions are violated:
Both x and y must be [valid] for both reads and writes of count * size_of::<T>() bytes.
Both x and y must be properly aligned.
The region of memory beginning at x with a size of count size_of::<T>() bytes must not* overlap with the region of memory beginning at y with the same size.
Note that even if the effectively copied size (count * size_of::<T>()) is 0, the pointers must be properly aligned.
Behavior is undefined if any of the following conditions are violated:
dst must be [valid] for writes of count * size_of::<T>() bytes.
dst must be properly aligned.
Note that even if the effectively copied size (count * size_of::<T>()) is 0, the pointer must be properly aligned.
Additionally, note that changing *dst in this way can easily lead to undefined behavior (UB) later if the written bytes are not a valid representation of some T. For instance, the following is an incorrect use of this function:
``rust,no_run unsafe { let mut value: u8 = 0; let ptr: mut bool = &mut value as mut u8 as *mut bool; let _bool = ptr.read(); // This is fine, ptr points to a valid bool. ptr.write_bytes(42u8, 1); // This function itself does not cause UB... let _bool = ptr.read(); // ...but it makes this operation UB! ⚠️ } ``
Behavior is undefined if any of the following conditions are violated:
dst must be either [valid] for writes, or T must be a ZST, or dst must point to memory outside of all Rust allocations and writing to that memory must:
not trap, and
not cause any memory inside a Rust allocation to be modified.
dst must be properly aligned.
Note that even if T has size 0, the pointer must be properly aligned.
If any of the following conditions are violated, the result is Undefined Behavior:
The offset in bytes, count * size_of::<T>(), computed on mathematical integers (without "wrapping around"), must fit in an isize.
Let result be self.addr() + count * size_of::<T>(), computed on mathematical integers. This must fit in a usize.
If the computed offset is non-zero, then self must be [derived from][crate::ptr#provenance] a pointer to some [allocation], and the entire memory range between self and result (i.e., self.addr()..result) must be in bounds of that allocation.
Allocations can never be larger than isize::MAX bytes and they can only contain addresses representable by usize, so technically the last condition implies the first two. This implies, for instance, that vec.as_ptr().add(vec.len()) (for vec: Vec<T>) is always safe.
When calling this method, you have to ensure that the pointer is convertible to a reference. Note that because the created reference is to MaybeUninit<T>, the source pointer can point to uninitialized memory.
When calling this method, you have to ensure that the pointer is convertible to a reference. Note that because the created reference is to MaybeUninit<T>, the source pointer can point to uninitialized memory.
When calling this method, you have to ensure that all of the following is true:
The pointer must be [valid] for reads for ptr.len() * size_of::<T>() many bytes, and it must be properly aligned. This means in particular:
The entire memory range of this slice must be contained within a single allocation! Slices can never span across multiple allocations.
The pointer must be aligned even for zero-length slices. One reason for this is that enum layout optimizations may rely on references (including slices of any length) being aligned and non-null to distinguish them from other data. You can obtain a pointer that is usable as data for zero-length slices using NonNull::dangling().
The total size ptr.len() * size_of::<T>() of the slice must be no larger than isize::MAX. See the safety documentation of pointer::offset.
You must enforce Rust's aliasing rules, since the returned lifetime 'a is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, while this reference exists, the memory the pointer points to must not get mutated (except inside UnsafeCell).
This applies even if the result of this method is unused!
When calling this method, you have to ensure that all of the following is true:
The pointer must be [valid] for reads and writes for ptr.len() * size_of::<T>() many bytes, and it must be properly aligned. This means in particular:
The entire memory range of this slice must be contained within a single allocation! Slices can never span across multiple allocations.
The pointer must be aligned even for zero-length slices. One reason for this is that enum layout optimizations may rely on references (including slices of any length) being aligned and non-null to distinguish them from other data. You can obtain a pointer that is usable as data for zero-length slices using NonNull::dangling().
The total size ptr.len() * size_of::<T>() of the slice must be no larger than isize::MAX. See the safety documentation of pointer::offset.
You must enforce Rust's aliasing rules, since the returned lifetime 'a is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, while this reference exists, the memory the pointer points to must not get accessed (read or written) through any other pointer.
This applies even if the result of this method is unused!
If any of the following conditions are violated, the result is Undefined Behavior:
The offset in bytes, count * size_of::<T>(), computed on mathematical integers (without "wrapping around"), must fit in an isize.
Let result be self.addr() + count * size_of::<T>(), computed on mathematical integers. This must fit in a usize.
If the computed offset is non-zero, then self must be [derived from][crate::ptr#provenance] a pointer to some [allocation], and the entire memory range between self and result (i.e., min(self.addr(), result)..max(self.addr(), result)) must be in bounds of that allocation.
Allocations can never be larger than isize::MAX bytes and they can only contain addresses representable by usize, so technically the last condition implies the first two. This implies, for instance, that vec.as_ptr().offset(vec.len() as isize) (for vec: Vec<T>) is always safe.
If any of the following conditions are violated, the result is Undefined Behavior:
self and origin must either
point to the same address, or
both be derived from a pointer to the same [allocation], and the memory range between the two pointers must be in bounds of that object. (See below for an example.)
The distance between the pointers, in bytes, must be an exact multiple of the size of T.
As a consequence, the absolute distance between the pointers, in bytes, computed on mathematical integers (without "wrapping around"), cannot overflow an isize. This is implied by the in-bounds requirement, and the fact that no allocation can be larger than isize::MAX bytes.
The requirement for pointers to be derived from the same allocation is primarily needed for const-compatibility: the distance between pointers into different allocated objects is not known at compile-time. However, the requirement also exists at runtime and may be exploited by optimizations. If you wish to compute the difference between pointers that are not guaranteed to be from the same allocation, use (self.addr() as isize - origin.addr() as isize) / size_of::<T>().
The distance between the pointers must be non-negative (self >= origin)
All the safety conditions of offset_from(#method.offset_from) apply to this method as well; see it for the full details.
Importantly, despite the return type of this method being able to represent a larger offset, it's still not permitted to pass pointers which differ by more than isize::MAXbytes. As such, the result of this method will always be less than or equal to isize::MAX as usize.
If any of the following conditions are violated, the result is Undefined Behavior:
The offset in bytes, count * size_of::<T>(), computed on mathematical integers (without "wrapping around"), must fit in an isize.
Let result be self.addr() - count * size_of::<T>(), computed on mathematical integers. This must fit in a usize.
If the computed offset is non-zero, then self must be [derived from][crate::ptr#provenance] a pointer to some [allocation], and the entire memory range between self and result (i.e., result..self.addr()) must be in bounds of that allocation.
Allocations can never be larger than isize::MAX bytes and they can only contain addresses representable by usize, so technically the last condition implies the first two.
This method is essentially a transmute with respect to the elements in the returned middle slice, so all the usual caveats pertaining to transmute::<T, U> also apply here.
This method is essentially a transmute with respect to the elements in the returned middle slice, so all the usual caveats pertaining to transmute::<T, U> also apply here.
It is up to the caller to guarantee that every MaybeUninit<T> in the slice really is in an initialized state. Calling this when the content is not yet fully initialized causes undefined behavior.
On top of that, all additional invariants of the type T must be satisfied, as the Drop implementation of T (or its members) may rely on this. For example, setting a Vec<T> to an invalid but non-null address makes it initialized (under the current implementation; this does not constitute a stable guarantee), because the only requirement the compiler knows about it is that the data pointer must be non-null. Dropping such a Vec<T> however will cause undefined behaviour.
Calling this when the content is not yet fully initialized causes undefined behavior: it is up to the caller to guarantee that every MaybeUninit<T> in the slice really is in an initialized state. For instance, .assume_init_mut() cannot be used to initialize a MaybeUninit slice.
Calling this when the content is not yet fully initialized causes undefined behavior: it is up to the caller to guarantee that every MaybeUninit<T> in the slice really is in an initialized state.
Behavior is undefined if any of the following conditions are violated:
The start pointer of the range must be a non-null, [valid] and properly aligned pointer to the first element of a slice.
The end pointer must be a [valid] and properly aligned pointer to one past the last element, such that the offset from the end to the start pointer is the length of the slice.
The entire memory range of this slice must be contained within a single allocation! Slices can never span across multiple allocations.
The range must contain N consecutive properly initialized values of type T.
The memory referenced by the returned slice must not be accessed through any other pointer (not derived from the return value) for the duration of lifetime 'a. Both read and write accesses are forbidden.
The total length of the range must be no larger than isize::MAX, and adding that size to start must not "wrap around" the address space. See the safety documentation of pointer::offset.
Note that a range created from slice::as_mut_ptr_range fulfills these requirements.
Behavior is undefined if any of the following conditions are violated:
The start pointer of the range must be a non-null, [valid] and properly aligned pointer to the first element of a slice.
The end pointer must be a [valid] and properly aligned pointer to one past the last element, such that the offset from the end to the start pointer is the length of the slice.
The entire memory range of this slice must be contained within a single allocation! Slices can never span across multiple allocations.
The range must contain N consecutive properly initialized values of type T.
The memory referenced by the returned slice must not be mutated for the duration of lifetime 'a, except inside an UnsafeCell.
The total length of the range must be no larger than isize::MAX, and adding that size to start must not "wrap around" the address space. See the safety documentation of pointer::offset.
Note that a range created from slice::as_ptr_range fulfills these requirements.
Behavior is undefined if any of the following conditions are violated:
data must be non-null, [valid] for reads for len * size_of::<T>() many bytes, and it must be properly aligned. This means in particular:
The entire memory range of this slice must be contained within a single allocation! Slices can never span across multiple allocations. See below for an example incorrectly not taking this into account.
data must be non-null and aligned even for zero-length slices or slices of ZSTs. One reason for this is that enum layout optimizations may rely on references (including slices of any length) being aligned and non-null to distinguish them from other data. You can obtain a pointer that is usable as data for zero-length slices using NonNull::dangling().
data must point to len consecutive properly initialized values of type T.
The memory referenced by the returned slice must not be mutated for the duration of lifetime 'a, except inside an UnsafeCell.
The total size len * size_of::<T>() of the slice must be no larger than isize::MAX, and adding that size to data must not "wrap around" the address space. See the safety documentation of pointer::offset.
Behavior is undefined if any of the following conditions are violated:
data must be non-null, [valid] for both reads and writes for len * size_of::<T>() many bytes, and it must be properly aligned. This means in particular:
The entire memory range of this slice must be contained within a single allocation! Slices can never span across multiple allocations.
data must be non-null and aligned even for zero-length slices or slices of ZSTs. One reason for this is that enum layout optimizations may rely on references (including slices of any length) being aligned and non-null to distinguish them from other data. You can obtain a pointer that is usable as data for zero-length slices using NonNull::dangling().
data must point to len consecutive properly initialized values of type T.
The memory referenced by the returned slice must not be accessed through any other pointer (not derived from the return value) for the duration of lifetime 'a. Both read and write accesses are forbidden.
The total size len * size_of::<T>() of the slice must be no larger than isize::MAX, and adding that size to data must not "wrap around" the address space. See the safety documentation of pointer::offset.
Calling this method with an out-of-bounds index is [undefined behavior] even if the resulting reference is not used.
You can think of this like .get(index).unwrap_unchecked(). It's UB to call .get_unchecked(len), even if you immediately convert to a pointer. And it's UB to call .get_unchecked(..len + 1), .get_unchecked(..=len), or similar.
Calling this method with an out-of-bounds index is [undefined behavior] even if the resulting reference is not used.
You can think of this like .get_mut(index).unwrap_unchecked(). It's UB to call .get_unchecked_mut(len), even if you immediately convert to a pointer. And it's UB to call .get_unchecked_mut(..len + 1), .get_unchecked_mut(..=len), or similar.
Calling this method with an out-of-bounds index is [undefined behavior] even if the resulting reference is not used. The caller has to ensure that 0 <= mid <= self.len().
Calling this method with an out-of-bounds index is [undefined behavior] even if the resulting reference is not used. The caller has to ensure that 0 <= mid <= self.len().
ptr must be aligned to align_of::<AtomicU32>() (note that on some platforms this can be bigger than align_of::<u32>()).
ptr must be [valid] for both reads and writes for the whole lifetime 'a.
You must adhere to the [Memory model for atomic accesses]. In particular, it is not allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different sizes, without synchronization.
ptr must be aligned to align_of::<AtomicI32>() (note that on some platforms this can be bigger than align_of::<i32>()).
ptr must be [valid] for both reads and writes for the whole lifetime 'a.
You must adhere to the [Memory model for atomic accesses]. In particular, it is not allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different sizes, without synchronization.
ptr must be aligned to align_of::<AtomicUsize>() (note that on some platforms this can be bigger than align_of::<usize>()).
ptr must be [valid] for both reads and writes for the whole lifetime 'a.
You must adhere to the [Memory model for atomic accesses]. In particular, it is not allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different sizes, without synchronization.
ptr must be aligned to align_of::<AtomicU16>() (note that on some platforms this can be bigger than align_of::<u16>()).
ptr must be [valid] for both reads and writes for the whole lifetime 'a.
You must adhere to the [Memory model for atomic accesses]. In particular, it is not allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different sizes, without synchronization.
ptr must be aligned to align_of::<AtomicIsize>() (note that on some platforms this can be bigger than align_of::<isize>()).
ptr must be [valid] for both reads and writes for the whole lifetime 'a.
You must adhere to the [Memory model for atomic accesses]. In particular, it is not allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different sizes, without synchronization.
ptr must be aligned to align_of::<AtomicI8>() (note that this is always true, since align_of::<AtomicI8>() == 1).
ptr must be [valid] for both reads and writes for the whole lifetime 'a.
You must adhere to the [Memory model for atomic accesses]. In particular, it is not allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different sizes, without synchronization.
ptr must be aligned to align_of::<AtomicI16>() (note that on some platforms this can be bigger than align_of::<i16>()).
ptr must be [valid] for both reads and writes for the whole lifetime 'a.
You must adhere to the [Memory model for atomic accesses]. In particular, it is not allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different sizes, without synchronization.
ptr must be aligned to align_of::<AtomicU128>() (note that on some platforms this can be bigger than align_of::<u128>()).
ptr must be [valid] for both reads and writes for the whole lifetime 'a.
You must adhere to the [Memory model for atomic accesses]. In particular, it is not allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different sizes, without synchronization.
ptr must be aligned to align_of::<AtomicU8>() (note that this is always true, since align_of::<AtomicU8>() == 1).
ptr must be [valid] for both reads and writes for the whole lifetime 'a.
You must adhere to the [Memory model for atomic accesses]. In particular, it is not allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different sizes, without synchronization.
ptr must be aligned to align_of::<AtomicI128>() (note that on some platforms this can be bigger than align_of::<i128>()).
ptr must be [valid] for both reads and writes for the whole lifetime 'a.
You must adhere to the [Memory model for atomic accesses]. In particular, it is not allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different sizes, without synchronization.
ptr must be aligned to align_of::<AtomicU64>() (note that on some platforms this can be bigger than align_of::<u64>()).
ptr must be [valid] for both reads and writes for the whole lifetime 'a.
You must adhere to the [Memory model for atomic accesses]. In particular, it is not allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different sizes, without synchronization.
ptr must be aligned to align_of::<AtomicPtr<T>>() (note that on some platforms this can be bigger than align_of::<*mut T>()).
ptr must be [valid] for both reads and writes for the whole lifetime 'a.
You must adhere to the [Memory model for atomic accesses]. In particular, it is not allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different sizes, without synchronization.
ptr must be aligned to align_of::<AtomicI64>() (note that on some platforms this can be bigger than align_of::<i64>()).
ptr must be [valid] for both reads and writes for the whole lifetime 'a.
You must adhere to the [Memory model for atomic accesses]. In particular, it is not allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different sizes, without synchronization.
ptr must be aligned to align_of::<AtomicBool>() (note that this is always true, since align_of::<AtomicBool>() == 1).
ptr must be [valid] for both reads and writes for the whole lifetime 'a.
You must adhere to the [Memory model for atomic accesses]. In particular, it is not allowed to mix conflicting atomic and non-atomic accesses, or atomic accesses of different sizes, without synchronization.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use backward or backward_checked instead.
It is undefined behavior for this operation to overflow the range of values supported by Self. If you cannot guarantee that this will not overflow, use forward or forward_checked instead.
layout must have non-zero size. Attempting to allocate for a zero-sized layout will result in undefined behavior.
(Extension subtraits might provide more specific bounds on behavior, e.g., guarantee a sentinel address or a null pointer in response to a zero-size allocation request.)
The allocated block of memory may or may not be initialized.
The caller has to ensure that layout has non-zero size. Like alloc zero sized layout will result in undefined behavior. However the allocated block of memory is guaranteed to be initialized.
layout is the same layout that was used to allocate that block of memory,
new_size is greater than zero.
new_size, when rounded up to the nearest multiple of layout.align(), does not overflow isize (i.e., the rounded value must be less than or equal to isize::MAX).
If these are not followed, the behavior is undefined.
(Extension subtraits might provide more specific bounds on behavior, e.g., guarantee a sentinel address or a null pointer in response to a zero-size allocation request.)
This function is sound to call in a single-threaded program.
This function is also always sound to call on Windows, in single-threaded and multi-threaded programs.
In multi-threaded programs on other operating systems, the only sound option is to not use set_var or remove_var at all.
The exact requirement is: you must ensure that there are no other threads concurrently writing or reading(!) the environment through functions or global variables other than the ones in this module. The problem is that these operating systems do not provide a thread-safe way to read the environment, and most C libraries, including libc itself, do not advertise which functions read from the environment. Even functions from the Rust standard library may read the environment without going through this module, e.g. for DNS lookups from std::net::ToSocketAddrs. No stable guarantee is made about which functions may read from the environment in future versions of a library. All this makes it not practically possible for you to guarantee that no other thread will read the environment, so the only sound option is to not use set_var or remove_var in multi-threaded programs at all.
Discussion of this unsafety on Unix may be found in:
This function is sound to call in a single-threaded program.
This function is also always sound to call on Windows, in single-threaded and multi-threaded programs.
In multi-threaded programs on other operating systems, the only sound option is to not use set_var or remove_var at all.
The exact requirement is: you must ensure that there are no other threads concurrently writing or reading(!) the environment through functions or global variables other than the ones in this module. The problem is that these operating systems do not provide a thread-safe way to read the environment, and most C libraries, including libc itself, do not advertise which functions read from the environment. Even functions from the Rust standard library may read the environment without going through this module, e.g. for DNS lookups from std::net::ToSocketAddrs. No stable guarantee is made about which functions may read from the environment in future versions of a library. All this makes it not practically possible for you to guarantee that no other thread will read the environment, so the only sound option is to not use set_var or remove_var in multi-threaded programs at all.
Discussion of this unsafety on Unix may be found in:
As the encoding is unspecified, callers must pass in bytes that originated as a mixture of validated UTF-8 and bytes from OsStr::as_encoded_bytes from within the same Rust version built for the same target platform. For example, reconstructing an OsStr from bytes sent over the network or stored in a file will likely violate these safety rules.
Due to the encoding being self-synchronizing, the bytes from OsStr::as_encoded_bytes can be split either immediately before or immediately after any valid non-empty UTF-8 substring.
As the encoding is unspecified, callers must pass in bytes that originated as a mixture of validated UTF-8 and bytes from OsStr::as_encoded_bytes from within the same Rust version built for the same target platform. For example, reconstructing an OsString from bytes sent over the network or stored in a file will likely violate these safety rules.
Due to the encoding being self-synchronizing, the bytes from OsStr::as_encoded_bytes can be split either immediately before or immediately after any valid non-empty UTF-8 substring.
The handle passed in must: - be an [owned handle][io-safety]; in particular, it must be open. - be a handle for a resource that may be freed via CloseHandle (as opposed to RegCloseKey or other close functions).
Note that the handle may have the value INVALID_HANDLE_VALUE (-1), which is sometimes a valid handle value. See [here] for the full story.
This results in undefined behavior when rhs == 0, self % rhs != 0, or self == i128::MIN && rhs == -1, i.e. when checked_div_exact(Self::checked_div_exact) would return None.
This results in undefined behavior when rhs == 0, self % rhs != 0, or self == i16::MIN && rhs == -1, i.e. when checked_div_exact(Self::checked_div_exact) would return None.
This results in undefined behavior when rhs == 0, self % rhs != 0, or self == i32::MIN && rhs == -1, i.e. when checked_div_exact(Self::checked_div_exact) would return None.
This results in undefined behavior when rhs == 0, self % rhs != 0, or self == i64::MIN && rhs == -1, i.e. when checked_div_exact(Self::checked_div_exact) would return None.
This results in undefined behavior when rhs == 0, self % rhs != 0, or self == i8::MIN && rhs == -1, i.e. when checked_div_exact(Self::checked_div_exact) would return None.
The handle passed in must: - be an [owned handle][io-safety]; in particular, it must be open. - be a handle for a resource that may be freed via CloseHandle (as opposed to RegCloseKey or other close functions).
Note that the handle may have the value INVALID_HANDLE_VALUE (-1), which is sometimes a valid handle value. See [here] for the full story.
The handle passed in must: - be an [owned handle][io-safety]; in particular, it must be open. - be a handle for a resource that may be freed via CloseHandle (as opposed to RegCloseKey or other close functions).
Note that the handle may have the value INVALID_HANDLE_VALUE (-1), which is sometimes a valid handle value. See [here] for the full story.
This results in undefined behavior when rhs == 0, self % rhs != 0, or self == isize::MIN && rhs == -1, i.e. when checked_div_exact(Self::checked_div_exact) would return None.
The resource pointed to by fd must be open and suitable for assuming [ownership][io-safety]. The resource must not require any cleanup other than close.
The passed handle value must either satisfy the safety requirements of FromRawHandle::from_raw_handle, or be INVALID_HANDLE_VALUE (-1). Note that not all Windows APIs use INVALID_HANDLE_VALUE for errors; see [here] for the full story.
The passed handle value must either satisfy the safety requirements of FromRawHandle::from_raw_handle, or be null. Note that not all Windows APIs use null for errors; see [here] for the full story.
The handle passed in must: - be an [owned handle][io-safety]; in particular, it must be open. - be a handle for a resource that may be freed via CloseHandle (as opposed to RegCloseKey or other close functions).
Note that the handle may have the value INVALID_HANDLE_VALUE (-1), which is sometimes a valid handle value. See [here] for the full story.
The handle passed in must: - be an [owned handle][io-safety]; in particular, it must be open. - be a handle for a resource that may be freed via CloseHandle (as opposed to RegCloseKey or other close functions).
Note that the handle may have the value INVALID_HANDLE_VALUE (-1), which is sometimes a valid handle value. See [here] for the full story.
This function is marked as unsafe because it deals with raw pointers and sizes. It is the responsibility of the caller to ensure the value lives longer than the resulting ProcThreadAttributeList as well as the validity of the size parameter.
The handle passed in must: - be an [owned handle][io-safety]; in particular, it must be open. - be a handle for a resource that may be freed via CloseHandle (as opposed to RegCloseKey or other close functions).
Note that the handle may have the value INVALID_HANDLE_VALUE (-1), which is sometimes a valid handle value. See [here] for the full story.
The caller has to ensure that the spawned thread does not outlive any references in the supplied thread closure and its return type. This can be guaranteed in two ways:
ensure that joinJoinHandle::join is called before any referenced data is dropped
use only types with 'static lifetime bounds, i.e., those with no or only 'static references (both thread::Builder::spawnBuilder::spawn and thread::spawn enforce this property statically)