Generated from crates: core, alloc, std.
| Index | Module Path | API Name | Kind | Safety Doc | Mark |
|---|---|---|---|---|---|
| 1 | alloc::alloc | alloc | function | See [`GlobalAlloc::alloc`]. | |
| 2 | alloc::alloc | alloc_zeroed | function | See [`GlobalAlloc::alloc_zeroed`]. | |
| 3 | alloc::alloc | dealloc | function | See [`GlobalAlloc::dealloc`]. | |
| 4 | alloc::alloc | realloc | function | See [`GlobalAlloc::realloc`]. | |
| 5 | alloc::boxed::Box | assume_init | function | 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. [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init 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. [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init | |
| 6 | alloc::boxed::Box | downcast_unchecked | function | The contained value must be of type `T`. Calling this method with the incorrect type is *undefined behavior*. [`downcast`]: Self::downcast | |
| 7 | alloc::boxed::Box | from_non_null | function | 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. | |
| 8 | alloc::boxed::Box | from_non_null_in | function | 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. | |
| 9 | alloc::boxed::Box | from_raw | function | 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. | |
| 10 | alloc::boxed::Box | from_raw_in | function | 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. | |
| 11 | alloc::collections::binary_heap::BinaryHeap | as_mut_slice | function | 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. | |
| 12 | alloc::collections::binary_heap::BinaryHeap | from_raw_vec | function | The supplied `vec` must be a max-heap, i.e. for all indices `0 < i < vec.len()`, `vec[(i - 1) / 2] >= vec[i]`. | |
| 13 | alloc::collections::btree::map::CursorMut | insert_after_unchecked | function | You must ensure that the `BTreeMap` invariants are maintained. Specifically: * The key of the newly inserted element must be unique in the tree. * All keys in the tree must remain in sorted order. | |
| 14 | alloc::collections::btree::map::CursorMut | insert_before_unchecked | function | You must ensure that the `BTreeMap` invariants are maintained. Specifically: * The key of the newly inserted element must be unique in the tree. * All keys in the tree must remain in sorted order. | |
| 15 | alloc::collections::btree::map::CursorMut | with_mutable_key | function | Since this cursor allows mutating keys, you must ensure that the `BTreeMap` invariants are maintained. Specifically: * The key of the newly inserted element must be unique in the tree. * All keys in the tree must remain in sorted order. | |
| 16 | alloc::collections::btree::map::CursorMutKey | insert_after_unchecked | function | You must ensure that the `BTreeMap` invariants are maintained. Specifically: * The key of the newly inserted element must be unique in the tree. * All keys in the tree must remain in sorted order. | |
| 17 | alloc::collections::btree::map::CursorMutKey | insert_before_unchecked | function | You must ensure that the `BTreeMap` invariants are maintained. Specifically: * The key of the newly inserted element must be unique in the tree. * All keys in the tree must remain in sorted order. | |
| 18 | alloc::collections::btree::set::CursorMut | insert_after_unchecked | function | You must ensure that the `BTreeSet` invariants are maintained. Specifically: * The newly inserted element must be unique in the tree. * All elements in the tree must remain in sorted order. | |
| 19 | alloc::collections::btree::set::CursorMut | insert_before_unchecked | function | You must ensure that the `BTreeSet` invariants are maintained. Specifically: * The newly inserted element must be unique in the tree. * All elements in the tree must remain in sorted order. | |
| 20 | alloc::collections::btree::set::CursorMut | with_mutable_key | function | Since this cursor allows mutating elements, you must ensure that the `BTreeSet` invariants are maintained. Specifically: * The newly inserted element must be unique in the tree. * All elements in the tree must remain in sorted order. | |
| 21 | alloc::collections::btree::set::CursorMutKey | insert_after_unchecked | function | You must ensure that the `BTreeSet` invariants are maintained. Specifically: * The key of the newly inserted element must be unique in the tree. * All elements in the tree must remain in sorted order. | |
| 22 | alloc::collections::btree::set::CursorMutKey | insert_before_unchecked | function | You must ensure that the `BTreeSet` invariants are maintained. Specifically: * The newly inserted element must be unique in the tree. * All elements in the tree must remain in sorted order. | |
| 23 | alloc::ffi::c_str::CString | from_raw | function | 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. | |
| 24 | alloc::ffi::c_str::CString | from_vec_unchecked | function | The caller must ensure `v` contains no nul bytes in its contents. | |
| 25 | alloc::ffi::c_str::CString | from_vec_with_nul_unchecked | function | The given [`Vec`] **must** have one nul byte as its last element. This means it cannot be empty nor have any other nul byte anywhere else. | |
| 26 | alloc::rc::Rc | assume_init | function | 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. [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init | |
| 27 | alloc::rc::Rc | decrement_strong_count | function | 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. [from_raw_in]: Rc::from_raw_in | |
| 28 | alloc::rc::Rc | decrement_strong_count_in | function | 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 `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. [from_raw_in]: Rc::from_raw_in | |
| 29 | alloc::rc::Rc | downcast_unchecked | function | The contained value must be of type `T`. Calling this method with the incorrect type is *undefined behavior*. [`downcast`]: Self::downcast | |
| 30 | alloc::rc::Rc | from_raw | function | * 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. [into_raw]: Rc::into_raw [into_raw_with_allocator]: Rc::into_raw_with_allocator [transmute]: core::mem::transmute [unsized coercion]: https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions | |
| 31 | alloc::rc::Rc | from_raw_in | function | * 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. [into_raw]: Rc::into_raw [into_raw_with_allocator]: Rc::into_raw_with_allocator [transmute]: core::mem::transmute [unsized coercion]: https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions | |
| 32 | alloc::rc::Rc | get_mut_unchecked | function | 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`. | |
| 33 | alloc::rc::Rc | increment_strong_count | function | 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 the global allocator. [from_raw_in]: Rc::from_raw_in | |
| 34 | alloc::rc::Rc | increment_strong_count_in | function | 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`. [from_raw_in]: Rc::from_raw_in | |
| 35 | alloc::rc::Weak | from_raw | function | 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`]. | |
| 36 | alloc::rc::Weak | from_raw_in | function | 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`]. | |
| 37 | alloc::str | from_boxed_utf8_unchecked | function | * The provided bytes must contain a valid UTF-8 sequence. | |
| 38 | alloc::string::String | as_mut_vec | function | 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 `String`s are valid UTF-8. | |
| 39 | alloc::string::String | from_raw_parts | function | 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. | |
| 40 | alloc::string::String | from_utf8_unchecked | 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 `String`s are valid UTF-8. | |
| 41 | alloc::sync::Arc | assume_init | function | 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. [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init | |
| 42 | alloc::sync::Arc | decrement_strong_count | function | 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. [from_raw_in]: Arc::from_raw_in | |
| 43 | alloc::sync::Arc | decrement_strong_count_in | function | 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. [from_raw_in]: Arc::from_raw_in | |
| 44 | alloc::sync::Arc | downcast_unchecked | function | The contained value must be of type `T`. Calling this method with the incorrect type is *undefined behavior*. [`downcast`]: Self::downcast | |
| 45 | alloc::sync::Arc | from_raw | function | * 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. [into_raw]: Arc::into_raw [into_raw_with_allocator]: Arc::into_raw_with_allocator [transmute]: core::mem::transmute [unsized coercion]: https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions | |
| 46 | alloc::sync::Arc | from_raw_in | function | * 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. [into_raw]: Arc::into_raw [into_raw_with_allocator]: Arc::into_raw_with_allocator [transmute]: core::mem::transmute [unsized coercion]: https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions | |
| 47 | alloc::sync::Arc | get_mut_unchecked | function | 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`. | |
| 48 | alloc::sync::Arc | increment_strong_count | function | 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. [from_raw_in]: Arc::from_raw_in | |
| 49 | alloc::sync::Arc | increment_strong_count_in | function | 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`. [from_raw_in]: Arc::from_raw_in | |
| 50 | alloc::sync::Weak | from_raw | function | 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`]. | |
| 51 | alloc::sync::Weak | from_raw_in | function | 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`]. | |
| 52 | alloc::vec::Vec | from_parts | function | 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. [`String`]: crate::string::String [`alloc::alloc`]: crate::alloc::alloc [`dealloc`]: crate::alloc::GlobalAlloc::dealloc | |
| 53 | alloc::vec::Vec | from_parts_in | 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. [`String`]: crate::string::String [`dealloc`]: crate::alloc::GlobalAlloc::dealloc [*currently allocated*]: crate::alloc::Allocator#currently-allocated-memory [*fit*]: crate::alloc::Allocator#memory-fitting | |
| 54 | alloc::vec::Vec | from_raw_parts | 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. [`String`]: crate::string::String [`alloc::alloc`]: crate::alloc::alloc [`dealloc`]: crate::alloc::GlobalAlloc::dealloc | |
| 55 | alloc::vec::Vec | from_raw_parts_in | 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. [`String`]: crate::string::String [`dealloc`]: crate::alloc::GlobalAlloc::dealloc [*currently allocated*]: crate::alloc::Allocator#currently-allocated-memory [*fit*]: crate::alloc::Allocator#memory-fitting | |
| 56 | alloc::vec::Vec | set_len | function | - `new_len` must be less than or equal to [`capacity()`]. - The elements at `old_len..new_len` must be initialized. [`capacity()`]: Vec::capacity | |
| 57 | core::alloc | Allocator | trait | Memory blocks that are [*currently allocated*] by an allocator, must point to valid memory, and retain their validity until either: - the memory block is deallocated, or - the allocator is dropped. Copying, cloning, or moving the allocator must not invalidate memory blocks returned from it. A copied or cloned allocator must behave like the original allocator. A memory block which is [*currently allocated*] may be passed to any method of the allocator that accepts such an argument. 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. [*currently allocated*]: #currently-allocated-memory | |
| 58 | core::alloc | GlobalAlloc | trait | The `GlobalAlloc` trait is an `unsafe` trait for a number of reasons, and implementors must ensure that they adhere to these contracts: * 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. * `Layout` queries and calculations in general must be correct. Callers of this trait are allowed to rely on the contracts defined on each method, and implementors must ensure such contracts remain true. * 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. | |
| 59 | core::alloc::layout::Layout | for_value_raw | function | This function is only safe to call if the following conditions 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 for the type `T` 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 [`Layout::for_value`] on a reference to an extern type tail. - otherwise, it is conservatively not allowed to call this function. [trait object]: ../../book/ch17-02-trait-objects.html [extern type]: ../../unstable-book/language-features/extern-types.html | |
| 60 | core::alloc::layout::Layout | from_size_align_unchecked | function | This function is unsafe as it does not verify the preconditions from [`Layout::from_size_align`]. | |
| 61 | core::alloc::layout::Layout | from_size_alignment_unchecked | function | This function is unsafe as it does not verify the preconditions from [`Layout::from_size_alignment`]. | |
| 62 | core::array | as_ascii_unchecked | function | Every byte in the array must be in `0..=127`, or else this is UB. | |
| 63 | core::array::iter::IntoIter | new_unchecked | function | - The `buffer[initialized]` elements must all be initialized. - The range must be canonical, with `initialized.start <= initialized.end`. - The range must be in-bounds for the buffer, with `initialized.end <= N`. (Like how indexing `[0][100..100]` fails despite the range being empty.) It's sound to have more elements initialized than mentioned, though that will most likely result in them being leaked. | |
| 64 | core::ascii::ascii_char::AsciiChar | digit_unchecked | function | This is immediate UB if called with `d > 64`. 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.) | |
| 65 | core::ascii::ascii_char::AsciiChar | from_u8_unchecked | function | `b` must be in `0..=127`, or else this is UB. | |
| 66 | core::cell | CloneFromCell | trait | Implementing this trait for a type is sound if and only if the following code is sound for T = that type. ``` #![feature(cell_get_cloned)] | |
| 67 | core::cell::RefCell | try_borrow_unguarded | function | 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. | |
| 68 | core::cell::UnsafeCell | as_mut_unchecked | function | - It is Undefined Behavior to call this while any other reference(s) to the wrapped value are alive. - Mutating the wrapped value through other means while the returned reference is alive is Undefined Behavior. | |
| 69 | core::cell::UnsafeCell | as_ref_unchecked | function | - It is Undefined Behavior to call this while any mutable reference to the wrapped value is alive. - Mutating the wrapped value while the returned reference is alive is Undefined Behavior. | |
| 70 | core::cell::UnsafeCell | replace | function | The caller must take care to avoid aliasing and data races. - It is Undefined Behavior to allow calls to race with any other access to the wrapped value. - It is Undefined Behavior to call this while any other reference(s) to the wrapped value are alive. | |
| 71 | core::char | as_ascii_unchecked | function | This char must be within the ASCII range, or else this is UB. | |
| 72 | core::char | from_u32_unchecked | function | This function is unsafe, as it may construct invalid `char` values. For a safe version of this function, see the [`from_u32`] function. [`from_u32`]: #method.from_u32 | |
| 73 | core::clone | CloneToUninit | trait | 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`. | |
| 74 | core::clone | TrivialClone | trait | `Clone::clone` must be equivalent to copying the value, otherwise calling functions such as `slice::clone_from_slice` can have undefined behaviour. | |
| 75 | core::core_arch::aarch64::mte | __arm_mte_create_random_tag | function | ||
| 76 | core::core_arch::aarch64::mte | __arm_mte_exclude_tag | function | ||
| 77 | core::core_arch::aarch64::mte | __arm_mte_get_tag | function | ||
| 78 | core::core_arch::aarch64::mte | __arm_mte_increment_tag | function | ||
| 79 | core::core_arch::aarch64::mte | __arm_mte_ptrdiff | function | ||
| 80 | core::core_arch::aarch64::mte | __arm_mte_set_tag | function | ||
| 81 | core::core_arch::aarch64::neon | vld1_dup_f64 | function | ||
| 82 | core::core_arch::aarch64::neon | vld1_lane_f64 | function | ||
| 83 | core::core_arch::aarch64::neon | vld1q_dup_f64 | function | ||
| 84 | core::core_arch::aarch64::neon | vld1q_lane_f64 | function | ||
| 85 | core::core_arch::aarch64::neon::generated | vld1_f16 | function | * Neon intrinsic unsafe | |
| 86 | core::core_arch::aarch64::neon::generated | vld1_f32 | function | * Neon intrinsic unsafe | |
| 87 | core::core_arch::aarch64::neon::generated | vld1_f64 | function | * Neon intrinsic unsafe | |
| 88 | core::core_arch::aarch64::neon::generated | vld1_f64_x2 | function | * Neon intrinsic unsafe | |
| 89 | core::core_arch::aarch64::neon::generated | vld1_f64_x3 | function | * Neon intrinsic unsafe | |
| 90 | core::core_arch::aarch64::neon::generated | vld1_f64_x4 | function | * Neon intrinsic unsafe | |
| 91 | core::core_arch::aarch64::neon::generated | vld1_p16 | function | * Neon intrinsic unsafe | |
| 92 | core::core_arch::aarch64::neon::generated | vld1_p64 | function | * Neon intrinsic unsafe | |
| 93 | core::core_arch::aarch64::neon::generated | vld1_p8 | function | * Neon intrinsic unsafe | |
| 94 | core::core_arch::aarch64::neon::generated | vld1_s16 | function | * Neon intrinsic unsafe | |
| 95 | core::core_arch::aarch64::neon::generated | vld1_s32 | function | * Neon intrinsic unsafe | |
| 96 | core::core_arch::aarch64::neon::generated | vld1_s64 | function | * Neon intrinsic unsafe | |
| 97 | core::core_arch::aarch64::neon::generated | vld1_s8 | function | * Neon intrinsic unsafe | |
| 98 | core::core_arch::aarch64::neon::generated | vld1_u16 | function | * Neon intrinsic unsafe | |
| 99 | core::core_arch::aarch64::neon::generated | vld1_u32 | function | * Neon intrinsic unsafe | |
| 100 | core::core_arch::aarch64::neon::generated | vld1_u64 | function | * Neon intrinsic unsafe | |
| 101 | core::core_arch::aarch64::neon::generated | vld1_u8 | function | * Neon intrinsic unsafe | |
| 102 | core::core_arch::aarch64::neon::generated | vld1q_f16 | function | * Neon intrinsic unsafe | |
| 103 | core::core_arch::aarch64::neon::generated | vld1q_f32 | function | * Neon intrinsic unsafe | |
| 104 | core::core_arch::aarch64::neon::generated | vld1q_f64 | function | * Neon intrinsic unsafe | |
| 105 | core::core_arch::aarch64::neon::generated | vld1q_f64_x2 | function | * Neon intrinsic unsafe | |
| 106 | core::core_arch::aarch64::neon::generated | vld1q_f64_x3 | function | * Neon intrinsic unsafe | |
| 107 | core::core_arch::aarch64::neon::generated | vld1q_f64_x4 | function | * Neon intrinsic unsafe | |
| 108 | core::core_arch::aarch64::neon::generated | vld1q_p16 | function | * Neon intrinsic unsafe | |
| 109 | core::core_arch::aarch64::neon::generated | vld1q_p64 | function | * Neon intrinsic unsafe | |
| 110 | core::core_arch::aarch64::neon::generated | vld1q_p8 | function | * Neon intrinsic unsafe | |
| 111 | core::core_arch::aarch64::neon::generated | vld1q_s16 | function | * Neon intrinsic unsafe | |
| 112 | core::core_arch::aarch64::neon::generated | vld1q_s32 | function | * Neon intrinsic unsafe | |
| 113 | core::core_arch::aarch64::neon::generated | vld1q_s64 | function | * Neon intrinsic unsafe | |
| 114 | core::core_arch::aarch64::neon::generated | vld1q_s8 | function | * Neon intrinsic unsafe | |
| 115 | core::core_arch::aarch64::neon::generated | vld1q_u16 | function | * Neon intrinsic unsafe | |
| 116 | core::core_arch::aarch64::neon::generated | vld1q_u32 | function | * Neon intrinsic unsafe | |
| 117 | core::core_arch::aarch64::neon::generated | vld1q_u64 | function | * Neon intrinsic unsafe | |
| 118 | core::core_arch::aarch64::neon::generated | vld1q_u8 | function | * Neon intrinsic unsafe | |
| 119 | core::core_arch::aarch64::neon::generated | vld2_dup_f64 | function | * Neon intrinsic unsafe | |
| 120 | core::core_arch::aarch64::neon::generated | vld2_f64 | function | * Neon intrinsic unsafe | |
| 121 | core::core_arch::aarch64::neon::generated | vld2_lane_f64 | function | * Neon intrinsic unsafe | |
| 122 | core::core_arch::aarch64::neon::generated | vld2_lane_p64 | function | * Neon intrinsic unsafe | |
| 123 | core::core_arch::aarch64::neon::generated | vld2_lane_s64 | function | * Neon intrinsic unsafe | |
| 124 | core::core_arch::aarch64::neon::generated | vld2_lane_u64 | function | * Neon intrinsic unsafe | |
| 125 | core::core_arch::aarch64::neon::generated | vld2q_dup_f64 | function | * Neon intrinsic unsafe | |
| 126 | core::core_arch::aarch64::neon::generated | vld2q_dup_p64 | function | * Neon intrinsic unsafe | |
| 127 | core::core_arch::aarch64::neon::generated | vld2q_dup_s64 | function | * Neon intrinsic unsafe | |
| 128 | core::core_arch::aarch64::neon::generated | vld2q_dup_u64 | function | * Neon intrinsic unsafe | |
| 129 | core::core_arch::aarch64::neon::generated | vld2q_f64 | function | * Neon intrinsic unsafe | |
| 130 | core::core_arch::aarch64::neon::generated | vld2q_lane_f64 | function | * Neon intrinsic unsafe | |
| 131 | core::core_arch::aarch64::neon::generated | vld2q_lane_p64 | function | * Neon intrinsic unsafe | |
| 132 | core::core_arch::aarch64::neon::generated | vld2q_lane_p8 | function | * Neon intrinsic unsafe | |
| 133 | core::core_arch::aarch64::neon::generated | vld2q_lane_s64 | function | * Neon intrinsic unsafe | |
| 134 | core::core_arch::aarch64::neon::generated | vld2q_lane_s8 | function | * Neon intrinsic unsafe | |
| 135 | core::core_arch::aarch64::neon::generated | vld2q_lane_u64 | function | * Neon intrinsic unsafe | |
| 136 | core::core_arch::aarch64::neon::generated | vld2q_lane_u8 | function | * Neon intrinsic unsafe | |
| 137 | core::core_arch::aarch64::neon::generated | vld2q_p64 | function | * Neon intrinsic unsafe | |
| 138 | core::core_arch::aarch64::neon::generated | vld2q_s64 | function | * Neon intrinsic unsafe | |
| 139 | core::core_arch::aarch64::neon::generated | vld2q_u64 | function | * Neon intrinsic unsafe | |
| 140 | core::core_arch::aarch64::neon::generated | vld3_dup_f64 | function | * Neon intrinsic unsafe | |
| 141 | core::core_arch::aarch64::neon::generated | vld3_f64 | function | * Neon intrinsic unsafe | |
| 142 | core::core_arch::aarch64::neon::generated | vld3_lane_f64 | function | * Neon intrinsic unsafe | |
| 143 | core::core_arch::aarch64::neon::generated | vld3_lane_p64 | function | * Neon intrinsic unsafe | |
| 144 | core::core_arch::aarch64::neon::generated | vld3_lane_s64 | function | * Neon intrinsic unsafe | |
| 145 | core::core_arch::aarch64::neon::generated | vld3_lane_u64 | function | * Neon intrinsic unsafe | |
| 146 | core::core_arch::aarch64::neon::generated | vld3q_dup_f64 | function | * Neon intrinsic unsafe | |
| 147 | core::core_arch::aarch64::neon::generated | vld3q_dup_p64 | function | * Neon intrinsic unsafe | |
| 148 | core::core_arch::aarch64::neon::generated | vld3q_dup_s64 | function | * Neon intrinsic unsafe | |
| 149 | core::core_arch::aarch64::neon::generated | vld3q_dup_u64 | function | * Neon intrinsic unsafe | |
| 150 | core::core_arch::aarch64::neon::generated | vld3q_f64 | function | * Neon intrinsic unsafe | |
| 151 | core::core_arch::aarch64::neon::generated | vld3q_lane_f64 | function | * Neon intrinsic unsafe | |
| 152 | core::core_arch::aarch64::neon::generated | vld3q_lane_p64 | function | * Neon intrinsic unsafe | |
| 153 | core::core_arch::aarch64::neon::generated | vld3q_lane_p8 | function | * Neon intrinsic unsafe | |
| 154 | core::core_arch::aarch64::neon::generated | vld3q_lane_s64 | function | * Neon intrinsic unsafe | |
| 155 | core::core_arch::aarch64::neon::generated | vld3q_lane_s8 | function | * Neon intrinsic unsafe | |
| 156 | core::core_arch::aarch64::neon::generated | vld3q_lane_u64 | function | * Neon intrinsic unsafe | |
| 157 | core::core_arch::aarch64::neon::generated | vld3q_lane_u8 | function | * Neon intrinsic unsafe | |
| 158 | core::core_arch::aarch64::neon::generated | vld3q_p64 | function | * Neon intrinsic unsafe | |
| 159 | core::core_arch::aarch64::neon::generated | vld3q_s64 | function | * Neon intrinsic unsafe | |
| 160 | core::core_arch::aarch64::neon::generated | vld3q_u64 | function | * Neon intrinsic unsafe | |
| 161 | core::core_arch::aarch64::neon::generated | vld4_dup_f64 | function | * Neon intrinsic unsafe | |
| 162 | core::core_arch::aarch64::neon::generated | vld4_f64 | function | * Neon intrinsic unsafe | |
| 163 | core::core_arch::aarch64::neon::generated | vld4_lane_f64 | function | * Neon intrinsic unsafe | |
| 164 | core::core_arch::aarch64::neon::generated | vld4_lane_p64 | function | * Neon intrinsic unsafe | |
| 165 | core::core_arch::aarch64::neon::generated | vld4_lane_s64 | function | * Neon intrinsic unsafe | |
| 166 | core::core_arch::aarch64::neon::generated | vld4_lane_u64 | function | * Neon intrinsic unsafe | |
| 167 | core::core_arch::aarch64::neon::generated | vld4q_dup_f64 | function | * Neon intrinsic unsafe | |
| 168 | core::core_arch::aarch64::neon::generated | vld4q_dup_p64 | function | * Neon intrinsic unsafe | |
| 169 | core::core_arch::aarch64::neon::generated | vld4q_dup_s64 | function | * Neon intrinsic unsafe | |
| 170 | core::core_arch::aarch64::neon::generated | vld4q_dup_u64 | function | * Neon intrinsic unsafe | |
| 171 | core::core_arch::aarch64::neon::generated | vld4q_f64 | function | * Neon intrinsic unsafe | |
| 172 | core::core_arch::aarch64::neon::generated | vld4q_lane_f64 | function | * Neon intrinsic unsafe | |
| 173 | core::core_arch::aarch64::neon::generated | vld4q_lane_p64 | function | * Neon intrinsic unsafe | |
| 174 | core::core_arch::aarch64::neon::generated | vld4q_lane_p8 | function | * Neon intrinsic unsafe | |
| 175 | core::core_arch::aarch64::neon::generated | vld4q_lane_s64 | function | * Neon intrinsic unsafe | |
| 176 | core::core_arch::aarch64::neon::generated | vld4q_lane_s8 | function | * Neon intrinsic unsafe | |
| 177 | core::core_arch::aarch64::neon::generated | vld4q_lane_u64 | function | * Neon intrinsic unsafe | |
| 178 | core::core_arch::aarch64::neon::generated | vld4q_lane_u8 | function | * Neon intrinsic unsafe | |
| 179 | core::core_arch::aarch64::neon::generated | vld4q_p64 | function | * Neon intrinsic unsafe | |
| 180 | core::core_arch::aarch64::neon::generated | vld4q_s64 | function | * Neon intrinsic unsafe | |
| 181 | core::core_arch::aarch64::neon::generated | vld4q_u64 | function | * Neon intrinsic unsafe | |
| 182 | core::core_arch::aarch64::neon::generated | vldap1_lane_p64 | function | * Neon intrinsic unsafe | |
| 183 | core::core_arch::aarch64::neon::generated | vldap1_lane_s64 | function | * Neon intrinsic unsafe | |
| 184 | core::core_arch::aarch64::neon::generated | vldap1_lane_u64 | function | * Neon intrinsic unsafe | |
| 185 | core::core_arch::aarch64::neon::generated | vldap1q_lane_f64 | function | * Neon intrinsic unsafe | |
| 186 | core::core_arch::aarch64::neon::generated | vldap1q_lane_p64 | function | * Neon intrinsic unsafe | |
| 187 | core::core_arch::aarch64::neon::generated | vldap1q_lane_s64 | function | * Neon intrinsic unsafe | |
| 188 | core::core_arch::aarch64::neon::generated | vldap1q_lane_u64 | function | * Neon intrinsic unsafe | |
| 189 | core::core_arch::aarch64::neon::generated | vluti2_lane_f16 | function | * Neon intrinsic unsafe | |
| 190 | core::core_arch::aarch64::neon::generated | vluti2_lane_p16 | function | * Neon intrinsic unsafe | |
| 191 | core::core_arch::aarch64::neon::generated | vluti2_lane_p8 | function | * Neon intrinsic unsafe | |
| 192 | core::core_arch::aarch64::neon::generated | vluti2_lane_s16 | function | * Neon intrinsic unsafe | |
| 193 | core::core_arch::aarch64::neon::generated | vluti2_lane_s8 | function | * Neon intrinsic unsafe | |
| 194 | core::core_arch::aarch64::neon::generated | vluti2_lane_u16 | function | * Neon intrinsic unsafe | |
| 195 | core::core_arch::aarch64::neon::generated | vluti2_lane_u8 | function | * Neon intrinsic unsafe | |
| 196 | core::core_arch::aarch64::neon::generated | vluti2_laneq_f16 | function | * Neon intrinsic unsafe | |
| 197 | core::core_arch::aarch64::neon::generated | vluti2_laneq_p16 | function | * Neon intrinsic unsafe | |
| 198 | core::core_arch::aarch64::neon::generated | vluti2_laneq_p8 | function | * Neon intrinsic unsafe | |
| 199 | core::core_arch::aarch64::neon::generated | vluti2_laneq_s16 | function | * Neon intrinsic unsafe | |
| 200 | core::core_arch::aarch64::neon::generated | vluti2_laneq_s8 | function | * Neon intrinsic unsafe | |
| 201 | core::core_arch::aarch64::neon::generated | vluti2_laneq_u16 | function | * Neon intrinsic unsafe | |
| 202 | core::core_arch::aarch64::neon::generated | vluti2_laneq_u8 | function | * Neon intrinsic unsafe | |
| 203 | core::core_arch::aarch64::neon::generated | vluti2q_lane_f16 | function | * Neon intrinsic unsafe | |
| 204 | core::core_arch::aarch64::neon::generated | vluti2q_lane_p16 | function | * Neon intrinsic unsafe | |
| 205 | core::core_arch::aarch64::neon::generated | vluti2q_lane_p8 | function | * Neon intrinsic unsafe | |
| 206 | core::core_arch::aarch64::neon::generated | vluti2q_lane_s16 | function | * Neon intrinsic unsafe | |
| 207 | core::core_arch::aarch64::neon::generated | vluti2q_lane_s8 | function | * Neon intrinsic unsafe | |
| 208 | core::core_arch::aarch64::neon::generated | vluti2q_lane_u16 | function | * Neon intrinsic unsafe | |
| 209 | core::core_arch::aarch64::neon::generated | vluti2q_lane_u8 | function | * Neon intrinsic unsafe | |
| 210 | core::core_arch::aarch64::neon::generated | vluti2q_laneq_f16 | function | * Neon intrinsic unsafe | |
| 211 | core::core_arch::aarch64::neon::generated | vluti2q_laneq_p16 | function | * Neon intrinsic unsafe | |
| 212 | core::core_arch::aarch64::neon::generated | vluti2q_laneq_p8 | function | * Neon intrinsic unsafe | |
| 213 | core::core_arch::aarch64::neon::generated | vluti2q_laneq_s16 | function | * Neon intrinsic unsafe | |
| 214 | core::core_arch::aarch64::neon::generated | vluti2q_laneq_s8 | function | * Neon intrinsic unsafe | |
| 215 | core::core_arch::aarch64::neon::generated | vluti2q_laneq_u16 | function | * Neon intrinsic unsafe | |
| 216 | core::core_arch::aarch64::neon::generated | vluti2q_laneq_u8 | function | * Neon intrinsic unsafe | |
| 217 | core::core_arch::aarch64::neon::generated | vluti4q_lane_f16_x2 | function | * Neon intrinsic unsafe | |
| 218 | core::core_arch::aarch64::neon::generated | vluti4q_lane_p16_x2 | function | * Neon intrinsic unsafe | |
| 219 | core::core_arch::aarch64::neon::generated | vluti4q_lane_p8 | function | * Neon intrinsic unsafe | |
| 220 | core::core_arch::aarch64::neon::generated | vluti4q_lane_s16_x2 | function | * Neon intrinsic unsafe | |
| 221 | core::core_arch::aarch64::neon::generated | vluti4q_lane_s8 | function | * Neon intrinsic unsafe | |
| 222 | core::core_arch::aarch64::neon::generated | vluti4q_lane_u16_x2 | function | * Neon intrinsic unsafe | |
| 223 | core::core_arch::aarch64::neon::generated | vluti4q_lane_u8 | function | * Neon intrinsic unsafe | |
| 224 | core::core_arch::aarch64::neon::generated | vluti4q_laneq_f16_x2 | function | * Neon intrinsic unsafe | |
| 225 | core::core_arch::aarch64::neon::generated | vluti4q_laneq_p16_x2 | function | * Neon intrinsic unsafe | |
| 226 | core::core_arch::aarch64::neon::generated | vluti4q_laneq_p8 | function | * Neon intrinsic unsafe | |
| 227 | core::core_arch::aarch64::neon::generated | vluti4q_laneq_s16_x2 | function | * Neon intrinsic unsafe | |
| 228 | core::core_arch::aarch64::neon::generated | vluti4q_laneq_s8 | function | * Neon intrinsic unsafe | |
| 229 | core::core_arch::aarch64::neon::generated | vluti4q_laneq_u16_x2 | function | * Neon intrinsic unsafe | |
| 230 | core::core_arch::aarch64::neon::generated | vluti4q_laneq_u8 | function | * Neon intrinsic unsafe | |
| 231 | core::core_arch::aarch64::neon::generated | vst1_f16 | function | * Neon intrinsic unsafe | |
| 232 | core::core_arch::aarch64::neon::generated | vst1_f32 | function | * Neon intrinsic unsafe | |
| 233 | core::core_arch::aarch64::neon::generated | vst1_f64 | function | * Neon intrinsic unsafe | |
| 234 | core::core_arch::aarch64::neon::generated | vst1_f64_x2 | function | * Neon intrinsic unsafe | |
| 235 | core::core_arch::aarch64::neon::generated | vst1_f64_x3 | function | * Neon intrinsic unsafe | |
| 236 | core::core_arch::aarch64::neon::generated | vst1_f64_x4 | function | * Neon intrinsic unsafe | |
| 237 | core::core_arch::aarch64::neon::generated | vst1_lane_f64 | function | * Neon intrinsic unsafe | |
| 238 | core::core_arch::aarch64::neon::generated | vst1_p16 | function | * Neon intrinsic unsafe | |
| 239 | core::core_arch::aarch64::neon::generated | vst1_p64 | function | * Neon intrinsic unsafe | |
| 240 | core::core_arch::aarch64::neon::generated | vst1_p8 | function | * Neon intrinsic unsafe | |
| 241 | core::core_arch::aarch64::neon::generated | vst1_s16 | function | * Neon intrinsic unsafe | |
| 242 | core::core_arch::aarch64::neon::generated | vst1_s32 | function | * Neon intrinsic unsafe | |
| 243 | core::core_arch::aarch64::neon::generated | vst1_s64 | function | * Neon intrinsic unsafe | |
| 244 | core::core_arch::aarch64::neon::generated | vst1_s8 | function | * Neon intrinsic unsafe | |
| 245 | core::core_arch::aarch64::neon::generated | vst1_u16 | function | * Neon intrinsic unsafe | |
| 246 | core::core_arch::aarch64::neon::generated | vst1_u32 | function | * Neon intrinsic unsafe | |
| 247 | core::core_arch::aarch64::neon::generated | vst1_u64 | function | * Neon intrinsic unsafe | |
| 248 | core::core_arch::aarch64::neon::generated | vst1_u8 | function | * Neon intrinsic unsafe | |
| 249 | core::core_arch::aarch64::neon::generated | vst1q_f16 | function | * Neon intrinsic unsafe | |
| 250 | core::core_arch::aarch64::neon::generated | vst1q_f32 | function | * Neon intrinsic unsafe | |
| 251 | core::core_arch::aarch64::neon::generated | vst1q_f64 | function | * Neon intrinsic unsafe | |
| 252 | core::core_arch::aarch64::neon::generated | vst1q_f64_x2 | function | * Neon intrinsic unsafe | |
| 253 | core::core_arch::aarch64::neon::generated | vst1q_f64_x3 | function | * Neon intrinsic unsafe | |
| 254 | core::core_arch::aarch64::neon::generated | vst1q_f64_x4 | function | * Neon intrinsic unsafe | |
| 255 | core::core_arch::aarch64::neon::generated | vst1q_lane_f64 | function | * Neon intrinsic unsafe | |
| 256 | core::core_arch::aarch64::neon::generated | vst1q_p16 | function | * Neon intrinsic unsafe | |
| 257 | core::core_arch::aarch64::neon::generated | vst1q_p64 | function | * Neon intrinsic unsafe | |
| 258 | core::core_arch::aarch64::neon::generated | vst1q_p8 | function | * Neon intrinsic unsafe | |
| 259 | core::core_arch::aarch64::neon::generated | vst1q_s16 | function | * Neon intrinsic unsafe | |
| 260 | core::core_arch::aarch64::neon::generated | vst1q_s32 | function | * Neon intrinsic unsafe | |
| 261 | core::core_arch::aarch64::neon::generated | vst1q_s64 | function | * Neon intrinsic unsafe | |
| 262 | core::core_arch::aarch64::neon::generated | vst1q_s8 | function | * Neon intrinsic unsafe | |
| 263 | core::core_arch::aarch64::neon::generated | vst1q_u16 | function | * Neon intrinsic unsafe | |
| 264 | core::core_arch::aarch64::neon::generated | vst1q_u32 | function | * Neon intrinsic unsafe | |
| 265 | core::core_arch::aarch64::neon::generated | vst1q_u64 | function | * Neon intrinsic unsafe | |
| 266 | core::core_arch::aarch64::neon::generated | vst1q_u8 | function | * Neon intrinsic unsafe | |
| 267 | core::core_arch::aarch64::neon::generated | vst2_f64 | function | * Neon intrinsic unsafe | |
| 268 | core::core_arch::aarch64::neon::generated | vst2_lane_f64 | function | * Neon intrinsic unsafe | |
| 269 | core::core_arch::aarch64::neon::generated | vst2_lane_p64 | function | * Neon intrinsic unsafe | |
| 270 | core::core_arch::aarch64::neon::generated | vst2_lane_s64 | function | * Neon intrinsic unsafe | |
| 271 | core::core_arch::aarch64::neon::generated | vst2_lane_u64 | function | * Neon intrinsic unsafe | |
| 272 | core::core_arch::aarch64::neon::generated | vst2q_f64 | function | * Neon intrinsic unsafe | |
| 273 | core::core_arch::aarch64::neon::generated | vst2q_lane_f64 | function | * Neon intrinsic unsafe | |
| 274 | core::core_arch::aarch64::neon::generated | vst2q_lane_p64 | function | * Neon intrinsic unsafe | |
| 275 | core::core_arch::aarch64::neon::generated | vst2q_lane_p8 | function | * Neon intrinsic unsafe | |
| 276 | core::core_arch::aarch64::neon::generated | vst2q_lane_s64 | function | * Neon intrinsic unsafe | |
| 277 | core::core_arch::aarch64::neon::generated | vst2q_lane_s8 | function | * Neon intrinsic unsafe | |
| 278 | core::core_arch::aarch64::neon::generated | vst2q_lane_u64 | function | * Neon intrinsic unsafe | |
| 279 | core::core_arch::aarch64::neon::generated | vst2q_lane_u8 | function | * Neon intrinsic unsafe | |
| 280 | core::core_arch::aarch64::neon::generated | vst2q_p64 | function | * Neon intrinsic unsafe | |
| 281 | core::core_arch::aarch64::neon::generated | vst2q_s64 | function | * Neon intrinsic unsafe | |
| 282 | core::core_arch::aarch64::neon::generated | vst2q_u64 | function | * Neon intrinsic unsafe | |
| 283 | core::core_arch::aarch64::neon::generated | vst3_f64 | function | * Neon intrinsic unsafe | |
| 284 | core::core_arch::aarch64::neon::generated | vst3_lane_f64 | function | * Neon intrinsic unsafe | |
| 285 | core::core_arch::aarch64::neon::generated | vst3_lane_p64 | function | * Neon intrinsic unsafe | |
| 286 | core::core_arch::aarch64::neon::generated | vst3_lane_s64 | function | * Neon intrinsic unsafe | |
| 287 | core::core_arch::aarch64::neon::generated | vst3_lane_u64 | function | * Neon intrinsic unsafe | |
| 288 | core::core_arch::aarch64::neon::generated | vst3q_f64 | function | * Neon intrinsic unsafe | |
| 289 | core::core_arch::aarch64::neon::generated | vst3q_lane_f64 | function | * Neon intrinsic unsafe | |
| 290 | core::core_arch::aarch64::neon::generated | vst3q_lane_p64 | function | * Neon intrinsic unsafe | |
| 291 | core::core_arch::aarch64::neon::generated | vst3q_lane_p8 | function | * Neon intrinsic unsafe | |
| 292 | core::core_arch::aarch64::neon::generated | vst3q_lane_s64 | function | * Neon intrinsic unsafe | |
| 293 | core::core_arch::aarch64::neon::generated | vst3q_lane_s8 | function | * Neon intrinsic unsafe | |
| 294 | core::core_arch::aarch64::neon::generated | vst3q_lane_u64 | function | * Neon intrinsic unsafe | |
| 295 | core::core_arch::aarch64::neon::generated | vst3q_lane_u8 | function | * Neon intrinsic unsafe | |
| 296 | core::core_arch::aarch64::neon::generated | vst3q_p64 | function | * Neon intrinsic unsafe | |
| 297 | core::core_arch::aarch64::neon::generated | vst3q_s64 | function | * Neon intrinsic unsafe | |
| 298 | core::core_arch::aarch64::neon::generated | vst3q_u64 | function | * Neon intrinsic unsafe | |
| 299 | core::core_arch::aarch64::neon::generated | vst4_f64 | function | * Neon intrinsic unsafe | |
| 300 | core::core_arch::aarch64::neon::generated | vst4_lane_f64 | function | * Neon intrinsic unsafe | |
| 301 | core::core_arch::aarch64::neon::generated | vst4_lane_p64 | function | * Neon intrinsic unsafe | |
| 302 | core::core_arch::aarch64::neon::generated | vst4_lane_s64 | function | * Neon intrinsic unsafe | |
| 303 | core::core_arch::aarch64::neon::generated | vst4_lane_u64 | function | * Neon intrinsic unsafe | |
| 304 | core::core_arch::aarch64::neon::generated | vst4q_f64 | function | * Neon intrinsic unsafe | |
| 305 | core::core_arch::aarch64::neon::generated | vst4q_lane_f64 | function | * Neon intrinsic unsafe | |
| 306 | core::core_arch::aarch64::neon::generated | vst4q_lane_p64 | function | * Neon intrinsic unsafe | |
| 307 | core::core_arch::aarch64::neon::generated | vst4q_lane_p8 | function | * Neon intrinsic unsafe | |
| 308 | core::core_arch::aarch64::neon::generated | vst4q_lane_s64 | function | * Neon intrinsic unsafe | |
| 309 | core::core_arch::aarch64::neon::generated | vst4q_lane_s8 | function | * Neon intrinsic unsafe | |
| 310 | core::core_arch::aarch64::neon::generated | vst4q_lane_u64 | function | * Neon intrinsic unsafe | |
| 311 | core::core_arch::aarch64::neon::generated | vst4q_lane_u8 | function | * Neon intrinsic unsafe | |
| 312 | core::core_arch::aarch64::neon::generated | vst4q_p64 | function | * Neon intrinsic unsafe | |
| 313 | core::core_arch::aarch64::neon::generated | vst4q_s64 | function | * Neon intrinsic unsafe | |
| 314 | core::core_arch::aarch64::neon::generated | vst4q_u64 | function | * Neon intrinsic unsafe | |
| 315 | core::core_arch::aarch64::prefetch | _prefetch | function | ||
| 316 | core::core_arch::aarch64::rand | __rndr | function | ||
| 317 | core::core_arch::aarch64::rand | __rndrrs | function | ||
| 318 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_s64index_f64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 319 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_s64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 320 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_s64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 321 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_s64offset_f64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 322 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_s64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 323 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_s64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 324 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u32base_f32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 325 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u32base_index_f32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 326 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u32base_index_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 327 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u32base_index_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 328 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u32base_offset_f32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 329 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u32base_offset_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 330 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u32base_offset_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 331 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u32base_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 332 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u32base_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 333 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u32offset_f32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 334 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u32offset_s32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 335 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u32offset_u32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 336 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u64base_f64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 337 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u64base_index_f64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 338 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u64base_index_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 339 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u64base_index_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 340 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u64base_offset_f64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 341 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u64base_offset_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 342 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u64base_offset_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 343 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u64base_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 344 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u64base_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 345 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u64index_f64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 346 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 347 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 348 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u64offset_f64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 349 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 350 | core::core_arch::aarch64::sve2::generated | svldnt1_gather_u64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 351 | core::core_arch::aarch64::sve2::generated | svldnt1sb_gather_s64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 352 | core::core_arch::aarch64::sve2::generated | svldnt1sb_gather_s64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 353 | core::core_arch::aarch64::sve2::generated | svldnt1sb_gather_u32base_offset_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 354 | core::core_arch::aarch64::sve2::generated | svldnt1sb_gather_u32base_offset_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 355 | core::core_arch::aarch64::sve2::generated | svldnt1sb_gather_u32base_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 356 | core::core_arch::aarch64::sve2::generated | svldnt1sb_gather_u32base_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 357 | core::core_arch::aarch64::sve2::generated | svldnt1sb_gather_u32offset_s32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 358 | core::core_arch::aarch64::sve2::generated | svldnt1sb_gather_u32offset_u32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 359 | core::core_arch::aarch64::sve2::generated | svldnt1sb_gather_u64base_offset_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 360 | core::core_arch::aarch64::sve2::generated | svldnt1sb_gather_u64base_offset_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 361 | core::core_arch::aarch64::sve2::generated | svldnt1sb_gather_u64base_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 362 | core::core_arch::aarch64::sve2::generated | svldnt1sb_gather_u64base_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 363 | core::core_arch::aarch64::sve2::generated | svldnt1sb_gather_u64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 364 | core::core_arch::aarch64::sve2::generated | svldnt1sb_gather_u64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 365 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_s64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 366 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_s64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 367 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_s64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 368 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_s64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 369 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u32base_index_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 370 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u32base_index_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 371 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u32base_offset_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 372 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u32base_offset_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 373 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u32base_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 374 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u32base_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 375 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u32offset_s32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 376 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u32offset_u32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 377 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u64base_index_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 378 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u64base_index_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 379 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u64base_offset_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 380 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u64base_offset_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 381 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u64base_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 382 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u64base_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 383 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 384 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 385 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 386 | core::core_arch::aarch64::sve2::generated | svldnt1sh_gather_u64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 387 | core::core_arch::aarch64::sve2::generated | svldnt1sw_gather_s64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 388 | core::core_arch::aarch64::sve2::generated | svldnt1sw_gather_s64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 389 | core::core_arch::aarch64::sve2::generated | svldnt1sw_gather_s64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 390 | core::core_arch::aarch64::sve2::generated | svldnt1sw_gather_s64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 391 | core::core_arch::aarch64::sve2::generated | svldnt1sw_gather_u64base_index_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 392 | core::core_arch::aarch64::sve2::generated | svldnt1sw_gather_u64base_index_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 393 | core::core_arch::aarch64::sve2::generated | svldnt1sw_gather_u64base_offset_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 394 | core::core_arch::aarch64::sve2::generated | svldnt1sw_gather_u64base_offset_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 395 | core::core_arch::aarch64::sve2::generated | svldnt1sw_gather_u64base_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 396 | core::core_arch::aarch64::sve2::generated | svldnt1sw_gather_u64base_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 397 | core::core_arch::aarch64::sve2::generated | svldnt1sw_gather_u64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 398 | core::core_arch::aarch64::sve2::generated | svldnt1sw_gather_u64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 399 | core::core_arch::aarch64::sve2::generated | svldnt1sw_gather_u64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 400 | core::core_arch::aarch64::sve2::generated | svldnt1sw_gather_u64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 401 | core::core_arch::aarch64::sve2::generated | svldnt1ub_gather_s64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 402 | core::core_arch::aarch64::sve2::generated | svldnt1ub_gather_s64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 403 | core::core_arch::aarch64::sve2::generated | svldnt1ub_gather_u32base_offset_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 404 | core::core_arch::aarch64::sve2::generated | svldnt1ub_gather_u32base_offset_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 405 | core::core_arch::aarch64::sve2::generated | svldnt1ub_gather_u32base_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 406 | core::core_arch::aarch64::sve2::generated | svldnt1ub_gather_u32base_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 407 | core::core_arch::aarch64::sve2::generated | svldnt1ub_gather_u32offset_s32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 408 | core::core_arch::aarch64::sve2::generated | svldnt1ub_gather_u32offset_u32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 409 | core::core_arch::aarch64::sve2::generated | svldnt1ub_gather_u64base_offset_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 410 | core::core_arch::aarch64::sve2::generated | svldnt1ub_gather_u64base_offset_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 411 | core::core_arch::aarch64::sve2::generated | svldnt1ub_gather_u64base_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 412 | core::core_arch::aarch64::sve2::generated | svldnt1ub_gather_u64base_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 413 | core::core_arch::aarch64::sve2::generated | svldnt1ub_gather_u64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 414 | core::core_arch::aarch64::sve2::generated | svldnt1ub_gather_u64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 415 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_s64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 416 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_s64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 417 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_s64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 418 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_s64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 419 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u32base_index_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 420 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u32base_index_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 421 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u32base_offset_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 422 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u32base_offset_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 423 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u32base_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 424 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u32base_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 425 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u32offset_s32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 426 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u32offset_u32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 427 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u64base_index_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 428 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u64base_index_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 429 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u64base_offset_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 430 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u64base_offset_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 431 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u64base_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 432 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u64base_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 433 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 434 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 435 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 436 | core::core_arch::aarch64::sve2::generated | svldnt1uh_gather_u64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 437 | core::core_arch::aarch64::sve2::generated | svldnt1uw_gather_s64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 438 | core::core_arch::aarch64::sve2::generated | svldnt1uw_gather_s64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 439 | core::core_arch::aarch64::sve2::generated | svldnt1uw_gather_s64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 440 | core::core_arch::aarch64::sve2::generated | svldnt1uw_gather_s64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 441 | core::core_arch::aarch64::sve2::generated | svldnt1uw_gather_u64base_index_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 442 | core::core_arch::aarch64::sve2::generated | svldnt1uw_gather_u64base_index_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 443 | core::core_arch::aarch64::sve2::generated | svldnt1uw_gather_u64base_offset_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 444 | core::core_arch::aarch64::sve2::generated | svldnt1uw_gather_u64base_offset_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 445 | core::core_arch::aarch64::sve2::generated | svldnt1uw_gather_u64base_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 446 | core::core_arch::aarch64::sve2::generated | svldnt1uw_gather_u64base_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 447 | core::core_arch::aarch64::sve2::generated | svldnt1uw_gather_u64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 448 | core::core_arch::aarch64::sve2::generated | svldnt1uw_gather_u64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 449 | core::core_arch::aarch64::sve2::generated | svldnt1uw_gather_u64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 450 | core::core_arch::aarch64::sve2::generated | svldnt1uw_gather_u64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 451 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_s64index_f64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 452 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_s64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 453 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_s64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 454 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_s64offset_f64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 455 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_s64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 456 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_s64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 457 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u32base_f32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 458 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u32base_index_f32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 459 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u32base_index_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 460 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u32base_index_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 461 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u32base_offset_f32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 462 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u32base_offset_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 463 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u32base_offset_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 464 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u32base_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 465 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u32base_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 466 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u32offset_f32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 467 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u32offset_s32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 468 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u32offset_u32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 469 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u64base_f64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 470 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u64base_index_f64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 471 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u64base_index_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 472 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u64base_index_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 473 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u64base_offset_f64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 474 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u64base_offset_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 475 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u64base_offset_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 476 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u64base_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 477 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u64base_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 478 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u64index_f64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 479 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 480 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 481 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u64offset_f64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 482 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 483 | core::core_arch::aarch64::sve2::generated | svstnt1_scatter_u64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 484 | core::core_arch::aarch64::sve2::generated | svstnt1b_scatter_s64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 485 | core::core_arch::aarch64::sve2::generated | svstnt1b_scatter_s64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 486 | core::core_arch::aarch64::sve2::generated | svstnt1b_scatter_u32base_offset_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 487 | core::core_arch::aarch64::sve2::generated | svstnt1b_scatter_u32base_offset_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 488 | core::core_arch::aarch64::sve2::generated | svstnt1b_scatter_u32base_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 489 | core::core_arch::aarch64::sve2::generated | svstnt1b_scatter_u32base_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 490 | core::core_arch::aarch64::sve2::generated | svstnt1b_scatter_u32offset_s32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 491 | core::core_arch::aarch64::sve2::generated | svstnt1b_scatter_u32offset_u32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 492 | core::core_arch::aarch64::sve2::generated | svstnt1b_scatter_u64base_offset_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 493 | core::core_arch::aarch64::sve2::generated | svstnt1b_scatter_u64base_offset_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 494 | core::core_arch::aarch64::sve2::generated | svstnt1b_scatter_u64base_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 495 | core::core_arch::aarch64::sve2::generated | svstnt1b_scatter_u64base_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 496 | core::core_arch::aarch64::sve2::generated | svstnt1b_scatter_u64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 497 | core::core_arch::aarch64::sve2::generated | svstnt1b_scatter_u64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 498 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_s64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 499 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_s64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 500 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_s64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 501 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_s64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 502 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u32base_index_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 503 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u32base_index_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 504 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u32base_offset_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 505 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u32base_offset_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 506 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u32base_s32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 507 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u32base_u32 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 508 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u32offset_s32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 509 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u32offset_u32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 510 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u64base_index_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 511 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u64base_index_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 512 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u64base_offset_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 513 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u64base_offset_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 514 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u64base_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 515 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u64base_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 516 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 517 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 518 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 519 | core::core_arch::aarch64::sve2::generated | svstnt1h_scatter_u64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 520 | core::core_arch::aarch64::sve2::generated | svstnt1w_scatter_s64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 521 | core::core_arch::aarch64::sve2::generated | svstnt1w_scatter_s64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 522 | core::core_arch::aarch64::sve2::generated | svstnt1w_scatter_s64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 523 | core::core_arch::aarch64::sve2::generated | svstnt1w_scatter_s64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 524 | core::core_arch::aarch64::sve2::generated | svstnt1w_scatter_u64base_index_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 525 | core::core_arch::aarch64::sve2::generated | svstnt1w_scatter_u64base_index_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 526 | core::core_arch::aarch64::sve2::generated | svstnt1w_scatter_u64base_offset_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 527 | core::core_arch::aarch64::sve2::generated | svstnt1w_scatter_u64base_offset_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 528 | core::core_arch::aarch64::sve2::generated | svstnt1w_scatter_u64base_s64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 529 | core::core_arch::aarch64::sve2::generated | svstnt1w_scatter_u64base_u64 | function | * [`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. * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 530 | core::core_arch::aarch64::sve2::generated | svstnt1w_scatter_u64index_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 531 | core::core_arch::aarch64::sve2::generated | svstnt1w_scatter_u64index_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 532 | core::core_arch::aarch64::sve2::generated | svstnt1w_scatter_u64offset_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 533 | core::core_arch::aarch64::sve2::generated | svstnt1w_scatter_u64offset_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 534 | core::core_arch::aarch64::sve2::generated | svwhilerw_f32 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 535 | core::core_arch::aarch64::sve2::generated | svwhilerw_f64 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 536 | core::core_arch::aarch64::sve2::generated | svwhilerw_s16 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 537 | core::core_arch::aarch64::sve2::generated | svwhilerw_s32 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 538 | core::core_arch::aarch64::sve2::generated | svwhilerw_s64 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 539 | core::core_arch::aarch64::sve2::generated | svwhilerw_s8 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 540 | core::core_arch::aarch64::sve2::generated | svwhilerw_u16 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 541 | core::core_arch::aarch64::sve2::generated | svwhilerw_u32 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 542 | core::core_arch::aarch64::sve2::generated | svwhilerw_u64 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 543 | core::core_arch::aarch64::sve2::generated | svwhilerw_u8 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 544 | core::core_arch::aarch64::sve2::generated | svwhilewr_f32 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 545 | core::core_arch::aarch64::sve2::generated | svwhilewr_f64 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 546 | core::core_arch::aarch64::sve2::generated | svwhilewr_s16 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 547 | core::core_arch::aarch64::sve2::generated | svwhilewr_s32 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 548 | core::core_arch::aarch64::sve2::generated | svwhilewr_s64 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 549 | core::core_arch::aarch64::sve2::generated | svwhilewr_s8 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 550 | core::core_arch::aarch64::sve2::generated | svwhilewr_u16 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 551 | core::core_arch::aarch64::sve2::generated | svwhilewr_u32 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 552 | core::core_arch::aarch64::sve2::generated | svwhilewr_u64 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 553 | core::core_arch::aarch64::sve2::generated | svwhilewr_u8 | function | * [`pointer::byte_offset_from`](pointer#method.byte_offset_from) safety constraints must be met for at least the base pointers, `op1` and `op2`. | |
| 554 | core::core_arch::aarch64::sve::generated | svld1_f32 | function | * [`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`). | |
| 555 | core::core_arch::aarch64::sve::generated | svld1_f64 | function | * [`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`). | |
| 556 | core::core_arch::aarch64::sve::generated | svld1_gather_s32index_f32 | function | * [`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`). | |
| 557 | core::core_arch::aarch64::sve::generated | svld1_gather_s32index_s32 | function | * [`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`). | |
| 558 | core::core_arch::aarch64::sve::generated | svld1_gather_s32index_u32 | function | * [`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`). | |
| 559 | core::core_arch::aarch64::sve::generated | svld1_gather_s32offset_f32 | function | * [`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`). | |
| 560 | core::core_arch::aarch64::sve::generated | svld1_gather_s32offset_s32 | function | * [`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`). | |
| 561 | core::core_arch::aarch64::sve::generated | svld1_gather_s32offset_u32 | function | * [`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`). | |
| 562 | core::core_arch::aarch64::sve::generated | svld1_gather_s64index_f64 | function | * [`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`). | |
| 563 | core::core_arch::aarch64::sve::generated | svld1_gather_s64index_s64 | function | * [`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`). | |
| 564 | core::core_arch::aarch64::sve::generated | svld1_gather_s64index_u64 | function | * [`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`). | |
| 565 | core::core_arch::aarch64::sve::generated | svld1_gather_s64offset_f64 | function | * [`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`). | |
| 566 | core::core_arch::aarch64::sve::generated | svld1_gather_s64offset_s64 | function | * [`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`). | |
| 567 | core::core_arch::aarch64::sve::generated | svld1_gather_s64offset_u64 | function | * [`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`). | |
| 568 | core::core_arch::aarch64::sve::generated | svld1_gather_u32base_f32 | function | * [`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. | |
| 569 | core::core_arch::aarch64::sve::generated | svld1_gather_u32base_index_f32 | function | * [`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. | |
| 570 | core::core_arch::aarch64::sve::generated | svld1_gather_u32base_index_s32 | function | * [`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. | |
| 571 | core::core_arch::aarch64::sve::generated | svld1_gather_u32base_index_u32 | function | * [`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. | |
| 572 | core::core_arch::aarch64::sve::generated | svld1_gather_u32base_offset_f32 | function | * [`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. | |
| 573 | core::core_arch::aarch64::sve::generated | svld1_gather_u32base_offset_s32 | function | * [`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. | |
| 574 | core::core_arch::aarch64::sve::generated | svld1_gather_u32base_offset_u32 | function | * [`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. | |
| 575 | core::core_arch::aarch64::sve::generated | svld1_gather_u32base_s32 | function | * [`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. | |
| 576 | core::core_arch::aarch64::sve::generated | svld1_gather_u32base_u32 | function | * [`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. | |
| 577 | core::core_arch::aarch64::sve::generated | svld1_gather_u32index_f32 | function | * [`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`). | |
| 578 | core::core_arch::aarch64::sve::generated | svld1_gather_u32index_s32 | function | * [`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`). | |
| 579 | core::core_arch::aarch64::sve::generated | svld1_gather_u32index_u32 | function | * [`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`). | |
| 580 | core::core_arch::aarch64::sve::generated | svld1_gather_u32offset_f32 | function | * [`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`). | |
| 581 | core::core_arch::aarch64::sve::generated | svld1_gather_u32offset_s32 | function | * [`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`). | |
| 582 | core::core_arch::aarch64::sve::generated | svld1_gather_u32offset_u32 | function | * [`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`). | |
| 583 | core::core_arch::aarch64::sve::generated | svld1_gather_u64base_f64 | function | * [`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. | |
| 584 | core::core_arch::aarch64::sve::generated | svld1_gather_u64base_index_f64 | function | * [`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. | |
| 585 | core::core_arch::aarch64::sve::generated | svld1_gather_u64base_index_s64 | function | * [`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. | |
| 586 | core::core_arch::aarch64::sve::generated | svld1_gather_u64base_index_u64 | function | * [`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. | |
| 587 | core::core_arch::aarch64::sve::generated | svld1_gather_u64base_offset_f64 | function | * [`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. | |
| 588 | core::core_arch::aarch64::sve::generated | svld1_gather_u64base_offset_s64 | function | * [`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. | |
| 589 | core::core_arch::aarch64::sve::generated | svld1_gather_u64base_offset_u64 | function | * [`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. | |
| 590 | core::core_arch::aarch64::sve::generated | svld1_gather_u64base_s64 | function | * [`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. | |
| 591 | core::core_arch::aarch64::sve::generated | svld1_gather_u64base_u64 | function | * [`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. | |
| 592 | core::core_arch::aarch64::sve::generated | svld1_gather_u64index_f64 | function | * [`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`). | |
| 593 | core::core_arch::aarch64::sve::generated | svld1_gather_u64index_s64 | function | * [`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`). | |
| 594 | core::core_arch::aarch64::sve::generated | svld1_gather_u64index_u64 | function | * [`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`). | |
| 595 | core::core_arch::aarch64::sve::generated | svld1_gather_u64offset_f64 | function | * [`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`). | |
| 596 | core::core_arch::aarch64::sve::generated | svld1_gather_u64offset_s64 | function | * [`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`). | |
| 597 | core::core_arch::aarch64::sve::generated | svld1_gather_u64offset_u64 | function | * [`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`). | |
| 598 | core::core_arch::aarch64::sve::generated | svld1_s16 | function | * [`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`). | |
| 599 | core::core_arch::aarch64::sve::generated | svld1_s32 | function | * [`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`). | |
| 600 | core::core_arch::aarch64::sve::generated | svld1_s64 | function | * [`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`). | |
| 601 | core::core_arch::aarch64::sve::generated | svld1_s8 | function | * [`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`). | |
| 602 | core::core_arch::aarch64::sve::generated | svld1_u16 | function | * [`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`). | |
| 603 | core::core_arch::aarch64::sve::generated | svld1_u32 | function | * [`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`). | |
| 604 | core::core_arch::aarch64::sve::generated | svld1_u64 | function | * [`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`). | |
| 605 | core::core_arch::aarch64::sve::generated | svld1_u8 | function | * [`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`). | |
| 606 | core::core_arch::aarch64::sve::generated | svld1_vnum_f32 | function | * [`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`). | |
| 607 | core::core_arch::aarch64::sve::generated | svld1_vnum_f64 | function | * [`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`). | |
| 608 | core::core_arch::aarch64::sve::generated | svld1_vnum_s16 | function | * [`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`). | |
| 609 | core::core_arch::aarch64::sve::generated | svld1_vnum_s32 | function | * [`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`). | |
| 610 | core::core_arch::aarch64::sve::generated | svld1_vnum_s64 | function | * [`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`). | |
| 611 | core::core_arch::aarch64::sve::generated | svld1_vnum_s8 | function | * [`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`). | |
| 612 | core::core_arch::aarch64::sve::generated | svld1_vnum_u16 | function | * [`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`). | |
| 613 | core::core_arch::aarch64::sve::generated | svld1_vnum_u32 | function | * [`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`). | |
| 614 | core::core_arch::aarch64::sve::generated | svld1_vnum_u64 | function | * [`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`). | |
| 615 | core::core_arch::aarch64::sve::generated | svld1_vnum_u8 | function | * [`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`). | |
| 616 | core::core_arch::aarch64::sve::generated | svld1ro_f32 | function | * [`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`). | |
| 617 | core::core_arch::aarch64::sve::generated | svld1ro_f64 | function | * [`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`). | |
| 618 | core::core_arch::aarch64::sve::generated | svld1ro_s16 | function | * [`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`). | |
| 619 | core::core_arch::aarch64::sve::generated | svld1ro_s32 | function | * [`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`). | |
| 620 | core::core_arch::aarch64::sve::generated | svld1ro_s64 | function | * [`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`). | |
| 621 | core::core_arch::aarch64::sve::generated | svld1ro_s8 | function | * [`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`). | |
| 622 | core::core_arch::aarch64::sve::generated | svld1ro_u16 | function | * [`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`). | |
| 623 | core::core_arch::aarch64::sve::generated | svld1ro_u32 | function | * [`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`). | |
| 624 | core::core_arch::aarch64::sve::generated | svld1ro_u64 | function | * [`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`). | |
| 625 | core::core_arch::aarch64::sve::generated | svld1ro_u8 | function | * [`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`). | |
| 626 | core::core_arch::aarch64::sve::generated | svld1rq_f32 | function | * [`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`). | |
| 627 | core::core_arch::aarch64::sve::generated | svld1rq_f64 | function | * [`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`). | |
| 628 | core::core_arch::aarch64::sve::generated | svld1rq_s16 | function | * [`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`). | |
| 629 | core::core_arch::aarch64::sve::generated | svld1rq_s32 | function | * [`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`). | |
| 630 | core::core_arch::aarch64::sve::generated | svld1rq_s64 | function | * [`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`). | |
| 631 | core::core_arch::aarch64::sve::generated | svld1rq_s8 | function | * [`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`). | |
| 632 | core::core_arch::aarch64::sve::generated | svld1rq_u16 | function | * [`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`). | |
| 633 | core::core_arch::aarch64::sve::generated | svld1rq_u32 | function | * [`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`). | |
| 634 | core::core_arch::aarch64::sve::generated | svld1rq_u64 | function | * [`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`). | |
| 635 | core::core_arch::aarch64::sve::generated | svld1rq_u8 | function | * [`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`). | |
| 636 | core::core_arch::aarch64::sve::generated | svld1sb_gather_s32offset_s32 | function | * [`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`). | |
| 637 | core::core_arch::aarch64::sve::generated | svld1sb_gather_s32offset_u32 | function | * [`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`). | |
| 638 | core::core_arch::aarch64::sve::generated | svld1sb_gather_s64offset_s64 | function | * [`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`). | |
| 639 | core::core_arch::aarch64::sve::generated | svld1sb_gather_s64offset_u64 | function | * [`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`). | |
| 640 | core::core_arch::aarch64::sve::generated | svld1sb_gather_u32base_offset_s32 | function | * [`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. | |
| 641 | core::core_arch::aarch64::sve::generated | svld1sb_gather_u32base_offset_u32 | function | * [`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. | |
| 642 | core::core_arch::aarch64::sve::generated | svld1sb_gather_u32base_s32 | function | * [`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. | |
| 643 | core::core_arch::aarch64::sve::generated | svld1sb_gather_u32base_u32 | function | * [`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. | |
| 644 | core::core_arch::aarch64::sve::generated | svld1sb_gather_u32offset_s32 | function | * [`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`). | |
| 645 | core::core_arch::aarch64::sve::generated | svld1sb_gather_u32offset_u32 | function | * [`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`). | |
| 646 | core::core_arch::aarch64::sve::generated | svld1sb_gather_u64base_offset_s64 | function | * [`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. | |
| 647 | core::core_arch::aarch64::sve::generated | svld1sb_gather_u64base_offset_u64 | function | * [`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. | |
| 648 | core::core_arch::aarch64::sve::generated | svld1sb_gather_u64base_s64 | function | * [`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. | |
| 649 | core::core_arch::aarch64::sve::generated | svld1sb_gather_u64base_u64 | function | * [`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. | |
| 650 | core::core_arch::aarch64::sve::generated | svld1sb_gather_u64offset_s64 | function | * [`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`). | |
| 651 | core::core_arch::aarch64::sve::generated | svld1sb_gather_u64offset_u64 | function | * [`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`). | |
| 652 | core::core_arch::aarch64::sve::generated | svld1sb_s16 | function | * [`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`). | |
| 653 | core::core_arch::aarch64::sve::generated | svld1sb_s32 | function | * [`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`). | |
| 654 | core::core_arch::aarch64::sve::generated | svld1sb_s64 | function | * [`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`). | |
| 655 | core::core_arch::aarch64::sve::generated | svld1sb_u16 | function | * [`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`). | |
| 656 | core::core_arch::aarch64::sve::generated | svld1sb_u32 | function | * [`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`). | |
| 657 | core::core_arch::aarch64::sve::generated | svld1sb_u64 | function | * [`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`). | |
| 658 | core::core_arch::aarch64::sve::generated | svld1sb_vnum_s16 | function | * [`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`). | |
| 659 | core::core_arch::aarch64::sve::generated | svld1sb_vnum_s32 | function | * [`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`). | |
| 660 | core::core_arch::aarch64::sve::generated | svld1sb_vnum_s64 | function | * [`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`). | |
| 661 | core::core_arch::aarch64::sve::generated | svld1sb_vnum_u16 | function | * [`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`). | |
| 662 | core::core_arch::aarch64::sve::generated | svld1sb_vnum_u32 | function | * [`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`). | |
| 663 | core::core_arch::aarch64::sve::generated | svld1sb_vnum_u64 | function | * [`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`). | |
| 664 | core::core_arch::aarch64::sve::generated | svld1sh_gather_s32index_s32 | function | * [`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`). | |
| 665 | core::core_arch::aarch64::sve::generated | svld1sh_gather_s32index_u32 | function | * [`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`). | |
| 666 | core::core_arch::aarch64::sve::generated | svld1sh_gather_s32offset_s32 | function | * [`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`). | |
| 667 | core::core_arch::aarch64::sve::generated | svld1sh_gather_s32offset_u32 | function | * [`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`). | |
| 668 | core::core_arch::aarch64::sve::generated | svld1sh_gather_s64index_s64 | function | * [`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`). | |
| 669 | core::core_arch::aarch64::sve::generated | svld1sh_gather_s64index_u64 | function | * [`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`). | |
| 670 | core::core_arch::aarch64::sve::generated | svld1sh_gather_s64offset_s64 | function | * [`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`). | |
| 671 | core::core_arch::aarch64::sve::generated | svld1sh_gather_s64offset_u64 | function | * [`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`). | |
| 672 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u32base_index_s32 | function | * [`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. | |
| 673 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u32base_index_u32 | function | * [`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. | |
| 674 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u32base_offset_s32 | function | * [`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. | |
| 675 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u32base_offset_u32 | function | * [`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. | |
| 676 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u32base_s32 | function | * [`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. | |
| 677 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u32base_u32 | function | * [`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. | |
| 678 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u32index_s32 | function | * [`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`). | |
| 679 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u32index_u32 | function | * [`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`). | |
| 680 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u32offset_s32 | function | * [`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`). | |
| 681 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u32offset_u32 | function | * [`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`). | |
| 682 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u64base_index_s64 | function | * [`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. | |
| 683 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u64base_index_u64 | function | * [`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. | |
| 684 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u64base_offset_s64 | function | * [`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. | |
| 685 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u64base_offset_u64 | function | * [`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. | |
| 686 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u64base_s64 | function | * [`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. | |
| 687 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u64base_u64 | function | * [`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. | |
| 688 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u64index_s64 | function | * [`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`). | |
| 689 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u64index_u64 | function | * [`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`). | |
| 690 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u64offset_s64 | function | * [`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`). | |
| 691 | core::core_arch::aarch64::sve::generated | svld1sh_gather_u64offset_u64 | function | * [`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`). | |
| 692 | core::core_arch::aarch64::sve::generated | svld1sh_s32 | function | * [`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`). | |
| 693 | core::core_arch::aarch64::sve::generated | svld1sh_s64 | function | * [`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`). | |
| 694 | core::core_arch::aarch64::sve::generated | svld1sh_u32 | function | * [`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`). | |
| 695 | core::core_arch::aarch64::sve::generated | svld1sh_u64 | function | * [`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`). | |
| 696 | core::core_arch::aarch64::sve::generated | svld1sh_vnum_s32 | function | * [`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`). | |
| 697 | core::core_arch::aarch64::sve::generated | svld1sh_vnum_s64 | function | * [`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`). | |
| 698 | core::core_arch::aarch64::sve::generated | svld1sh_vnum_u32 | function | * [`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`). | |
| 699 | core::core_arch::aarch64::sve::generated | svld1sh_vnum_u64 | function | * [`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`). | |
| 700 | core::core_arch::aarch64::sve::generated | svld1sw_gather_s64index_s64 | function | * [`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`). | |
| 701 | core::core_arch::aarch64::sve::generated | svld1sw_gather_s64index_u64 | function | * [`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`). | |
| 702 | core::core_arch::aarch64::sve::generated | svld1sw_gather_s64offset_s64 | function | * [`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`). | |
| 703 | core::core_arch::aarch64::sve::generated | svld1sw_gather_s64offset_u64 | function | * [`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`). | |
| 704 | core::core_arch::aarch64::sve::generated | svld1sw_gather_u64base_index_s64 | function | * [`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. | |
| 705 | core::core_arch::aarch64::sve::generated | svld1sw_gather_u64base_index_u64 | function | * [`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. | |
| 706 | core::core_arch::aarch64::sve::generated | svld1sw_gather_u64base_offset_s64 | function | * [`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. | |
| 707 | core::core_arch::aarch64::sve::generated | svld1sw_gather_u64base_offset_u64 | function | * [`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. | |
| 708 | core::core_arch::aarch64::sve::generated | svld1sw_gather_u64base_s64 | function | * [`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. | |
| 709 | core::core_arch::aarch64::sve::generated | svld1sw_gather_u64base_u64 | function | * [`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. | |
| 710 | core::core_arch::aarch64::sve::generated | svld1sw_gather_u64index_s64 | function | * [`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`). | |
| 711 | core::core_arch::aarch64::sve::generated | svld1sw_gather_u64index_u64 | function | * [`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`). | |
| 712 | core::core_arch::aarch64::sve::generated | svld1sw_gather_u64offset_s64 | function | * [`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`). | |
| 713 | core::core_arch::aarch64::sve::generated | svld1sw_gather_u64offset_u64 | function | * [`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`). | |
| 714 | core::core_arch::aarch64::sve::generated | svld1sw_s64 | function | * [`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`). | |
| 715 | core::core_arch::aarch64::sve::generated | svld1sw_u64 | function | * [`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`). | |
| 716 | core::core_arch::aarch64::sve::generated | svld1sw_vnum_s64 | function | * [`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`). | |
| 717 | core::core_arch::aarch64::sve::generated | svld1sw_vnum_u64 | function | * [`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`). | |
| 718 | core::core_arch::aarch64::sve::generated | svld1ub_gather_s32offset_s32 | function | * [`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`). | |
| 719 | core::core_arch::aarch64::sve::generated | svld1ub_gather_s32offset_u32 | function | * [`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`). | |
| 720 | core::core_arch::aarch64::sve::generated | svld1ub_gather_s64offset_s64 | function | * [`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`). | |
| 721 | core::core_arch::aarch64::sve::generated | svld1ub_gather_s64offset_u64 | function | * [`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`). | |
| 722 | core::core_arch::aarch64::sve::generated | svld1ub_gather_u32base_offset_s32 | function | * [`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. | |
| 723 | core::core_arch::aarch64::sve::generated | svld1ub_gather_u32base_offset_u32 | function | * [`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. | |
| 724 | core::core_arch::aarch64::sve::generated | svld1ub_gather_u32base_s32 | function | * [`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. | |
| 725 | core::core_arch::aarch64::sve::generated | svld1ub_gather_u32base_u32 | function | * [`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. | |
| 726 | core::core_arch::aarch64::sve::generated | svld1ub_gather_u32offset_s32 | function | * [`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`). | |
| 727 | core::core_arch::aarch64::sve::generated | svld1ub_gather_u32offset_u32 | function | * [`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`). | |
| 728 | core::core_arch::aarch64::sve::generated | svld1ub_gather_u64base_offset_s64 | function | * [`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. | |
| 729 | core::core_arch::aarch64::sve::generated | svld1ub_gather_u64base_offset_u64 | function | * [`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. | |
| 730 | core::core_arch::aarch64::sve::generated | svld1ub_gather_u64base_s64 | function | * [`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. | |
| 731 | core::core_arch::aarch64::sve::generated | svld1ub_gather_u64base_u64 | function | * [`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. | |
| 732 | core::core_arch::aarch64::sve::generated | svld1ub_gather_u64offset_s64 | function | * [`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`). | |
| 733 | core::core_arch::aarch64::sve::generated | svld1ub_gather_u64offset_u64 | function | * [`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`). | |
| 734 | core::core_arch::aarch64::sve::generated | svld1ub_s16 | function | * [`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`). | |
| 735 | core::core_arch::aarch64::sve::generated | svld1ub_s32 | function | * [`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`). | |
| 736 | core::core_arch::aarch64::sve::generated | svld1ub_s64 | function | * [`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`). | |
| 737 | core::core_arch::aarch64::sve::generated | svld1ub_u16 | function | * [`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`). | |
| 738 | core::core_arch::aarch64::sve::generated | svld1ub_u32 | function | * [`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`). | |
| 739 | core::core_arch::aarch64::sve::generated | svld1ub_u64 | function | * [`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`). | |
| 740 | core::core_arch::aarch64::sve::generated | svld1ub_vnum_s16 | function | * [`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`). | |
| 741 | core::core_arch::aarch64::sve::generated | svld1ub_vnum_s32 | function | * [`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`). | |
| 742 | core::core_arch::aarch64::sve::generated | svld1ub_vnum_s64 | function | * [`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`). | |
| 743 | core::core_arch::aarch64::sve::generated | svld1ub_vnum_u16 | function | * [`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`). | |
| 744 | core::core_arch::aarch64::sve::generated | svld1ub_vnum_u32 | function | * [`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`). | |
| 745 | core::core_arch::aarch64::sve::generated | svld1ub_vnum_u64 | function | * [`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`). | |
| 746 | core::core_arch::aarch64::sve::generated | svld1uh_gather_s32index_s32 | function | * [`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`). | |
| 747 | core::core_arch::aarch64::sve::generated | svld1uh_gather_s32index_u32 | function | * [`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`). | |
| 748 | core::core_arch::aarch64::sve::generated | svld1uh_gather_s32offset_s32 | function | * [`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`). | |
| 749 | core::core_arch::aarch64::sve::generated | svld1uh_gather_s32offset_u32 | function | * [`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`). | |
| 750 | core::core_arch::aarch64::sve::generated | svld1uh_gather_s64index_s64 | function | * [`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`). | |
| 751 | core::core_arch::aarch64::sve::generated | svld1uh_gather_s64index_u64 | function | * [`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`). | |
| 752 | core::core_arch::aarch64::sve::generated | svld1uh_gather_s64offset_s64 | function | * [`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`). | |
| 753 | core::core_arch::aarch64::sve::generated | svld1uh_gather_s64offset_u64 | function | * [`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`). | |
| 754 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u32base_index_s32 | function | * [`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. | |
| 755 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u32base_index_u32 | function | * [`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. | |
| 756 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u32base_offset_s32 | function | * [`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. | |
| 757 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u32base_offset_u32 | function | * [`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. | |
| 758 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u32base_s32 | function | * [`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. | |
| 759 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u32base_u32 | function | * [`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. | |
| 760 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u32index_s32 | function | * [`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`). | |
| 761 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u32index_u32 | function | * [`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`). | |
| 762 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u32offset_s32 | function | * [`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`). | |
| 763 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u32offset_u32 | function | * [`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`). | |
| 764 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u64base_index_s64 | function | * [`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. | |
| 765 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u64base_index_u64 | function | * [`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. | |
| 766 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u64base_offset_s64 | function | * [`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. | |
| 767 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u64base_offset_u64 | function | * [`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. | |
| 768 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u64base_s64 | function | * [`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. | |
| 769 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u64base_u64 | function | * [`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. | |
| 770 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u64index_s64 | function | * [`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`). | |
| 771 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u64index_u64 | function | * [`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`). | |
| 772 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u64offset_s64 | function | * [`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`). | |
| 773 | core::core_arch::aarch64::sve::generated | svld1uh_gather_u64offset_u64 | function | * [`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`). | |
| 774 | core::core_arch::aarch64::sve::generated | svld1uh_s32 | function | * [`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`). | |
| 775 | core::core_arch::aarch64::sve::generated | svld1uh_s64 | function | * [`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`). | |
| 776 | core::core_arch::aarch64::sve::generated | svld1uh_u32 | function | * [`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`). | |
| 777 | core::core_arch::aarch64::sve::generated | svld1uh_u64 | function | * [`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`). | |
| 778 | core::core_arch::aarch64::sve::generated | svld1uh_vnum_s32 | function | * [`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`). | |
| 779 | core::core_arch::aarch64::sve::generated | svld1uh_vnum_s64 | function | * [`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`). | |
| 780 | core::core_arch::aarch64::sve::generated | svld1uh_vnum_u32 | function | * [`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`). | |
| 781 | core::core_arch::aarch64::sve::generated | svld1uh_vnum_u64 | function | * [`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`). | |
| 782 | core::core_arch::aarch64::sve::generated | svld1uw_gather_s64index_s64 | function | * [`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`). | |
| 783 | core::core_arch::aarch64::sve::generated | svld1uw_gather_s64index_u64 | function | * [`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`). | |
| 784 | core::core_arch::aarch64::sve::generated | svld1uw_gather_s64offset_s64 | function | * [`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`). | |
| 785 | core::core_arch::aarch64::sve::generated | svld1uw_gather_s64offset_u64 | function | * [`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`). | |
| 786 | core::core_arch::aarch64::sve::generated | svld1uw_gather_u64base_index_s64 | function | * [`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. | |
| 787 | core::core_arch::aarch64::sve::generated | svld1uw_gather_u64base_index_u64 | function | * [`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. | |
| 788 | core::core_arch::aarch64::sve::generated | svld1uw_gather_u64base_offset_s64 | function | * [`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. | |
| 789 | core::core_arch::aarch64::sve::generated | svld1uw_gather_u64base_offset_u64 | function | * [`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. | |
| 790 | core::core_arch::aarch64::sve::generated | svld1uw_gather_u64base_s64 | function | * [`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. | |
| 791 | core::core_arch::aarch64::sve::generated | svld1uw_gather_u64base_u64 | function | * [`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. | |
| 792 | core::core_arch::aarch64::sve::generated | svld1uw_gather_u64index_s64 | function | * [`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`). | |
| 793 | core::core_arch::aarch64::sve::generated | svld1uw_gather_u64index_u64 | function | * [`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`). | |
| 794 | core::core_arch::aarch64::sve::generated | svld1uw_gather_u64offset_s64 | function | * [`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`). | |
| 795 | core::core_arch::aarch64::sve::generated | svld1uw_gather_u64offset_u64 | function | * [`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`). | |
| 796 | core::core_arch::aarch64::sve::generated | svld1uw_s64 | function | * [`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`). | |
| 797 | core::core_arch::aarch64::sve::generated | svld1uw_u64 | function | * [`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`). | |
| 798 | core::core_arch::aarch64::sve::generated | svld1uw_vnum_s64 | function | * [`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`). | |
| 799 | core::core_arch::aarch64::sve::generated | svld1uw_vnum_u64 | function | * [`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`). | |
| 800 | core::core_arch::aarch64::sve::generated | svld2_f32 | function | * [`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`). | |
| 801 | core::core_arch::aarch64::sve::generated | svld2_f64 | function | * [`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`). | |
| 802 | core::core_arch::aarch64::sve::generated | svld2_s16 | function | * [`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`). | |
| 803 | core::core_arch::aarch64::sve::generated | svld2_s32 | function | * [`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`). | |
| 804 | core::core_arch::aarch64::sve::generated | svld2_s64 | function | * [`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`). | |
| 805 | core::core_arch::aarch64::sve::generated | svld2_s8 | function | * [`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`). | |
| 806 | core::core_arch::aarch64::sve::generated | svld2_u16 | function | * [`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`). | |
| 807 | core::core_arch::aarch64::sve::generated | svld2_u32 | function | * [`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`). | |
| 808 | core::core_arch::aarch64::sve::generated | svld2_u64 | function | * [`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`). | |
| 809 | core::core_arch::aarch64::sve::generated | svld2_u8 | function | * [`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`). | |
| 810 | core::core_arch::aarch64::sve::generated | svld2_vnum_f32 | function | * [`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`). | |
| 811 | core::core_arch::aarch64::sve::generated | svld2_vnum_f64 | function | * [`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`). | |
| 812 | core::core_arch::aarch64::sve::generated | svld2_vnum_s16 | function | * [`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`). | |
| 813 | core::core_arch::aarch64::sve::generated | svld2_vnum_s32 | function | * [`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`). | |
| 814 | core::core_arch::aarch64::sve::generated | svld2_vnum_s64 | function | * [`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`). | |
| 815 | core::core_arch::aarch64::sve::generated | svld2_vnum_s8 | function | * [`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`). | |
| 816 | core::core_arch::aarch64::sve::generated | svld2_vnum_u16 | function | * [`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`). | |
| 817 | core::core_arch::aarch64::sve::generated | svld2_vnum_u32 | function | * [`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`). | |
| 818 | core::core_arch::aarch64::sve::generated | svld2_vnum_u64 | function | * [`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`). | |
| 819 | core::core_arch::aarch64::sve::generated | svld2_vnum_u8 | function | * [`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`). | |
| 820 | core::core_arch::aarch64::sve::generated | svld3_f32 | function | * [`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`). | |
| 821 | core::core_arch::aarch64::sve::generated | svld3_f64 | function | * [`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`). | |
| 822 | core::core_arch::aarch64::sve::generated | svld3_s16 | function | * [`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`). | |
| 823 | core::core_arch::aarch64::sve::generated | svld3_s32 | function | * [`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`). | |
| 824 | core::core_arch::aarch64::sve::generated | svld3_s64 | function | * [`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`). | |
| 825 | core::core_arch::aarch64::sve::generated | svld3_s8 | function | * [`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`). | |
| 826 | core::core_arch::aarch64::sve::generated | svld3_u16 | function | * [`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`). | |
| 827 | core::core_arch::aarch64::sve::generated | svld3_u32 | function | * [`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`). | |
| 828 | core::core_arch::aarch64::sve::generated | svld3_u64 | function | * [`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`). | |
| 829 | core::core_arch::aarch64::sve::generated | svld3_u8 | function | * [`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`). | |
| 830 | core::core_arch::aarch64::sve::generated | svld3_vnum_f32 | function | * [`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`). | |
| 831 | core::core_arch::aarch64::sve::generated | svld3_vnum_f64 | function | * [`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`). | |
| 832 | core::core_arch::aarch64::sve::generated | svld3_vnum_s16 | function | * [`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`). | |
| 833 | core::core_arch::aarch64::sve::generated | svld3_vnum_s32 | function | * [`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`). | |
| 834 | core::core_arch::aarch64::sve::generated | svld3_vnum_s64 | function | * [`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`). | |
| 835 | core::core_arch::aarch64::sve::generated | svld3_vnum_s8 | function | * [`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`). | |
| 836 | core::core_arch::aarch64::sve::generated | svld3_vnum_u16 | function | * [`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`). | |
| 837 | core::core_arch::aarch64::sve::generated | svld3_vnum_u32 | function | * [`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`). | |
| 838 | core::core_arch::aarch64::sve::generated | svld3_vnum_u64 | function | * [`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`). | |
| 839 | core::core_arch::aarch64::sve::generated | svld3_vnum_u8 | function | * [`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`). | |
| 840 | core::core_arch::aarch64::sve::generated | svld4_f32 | function | * [`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`). | |
| 841 | core::core_arch::aarch64::sve::generated | svld4_f64 | function | * [`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`). | |
| 842 | core::core_arch::aarch64::sve::generated | svld4_s16 | function | * [`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`). | |
| 843 | core::core_arch::aarch64::sve::generated | svld4_s32 | function | * [`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`). | |
| 844 | core::core_arch::aarch64::sve::generated | svld4_s64 | function | * [`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`). | |
| 845 | core::core_arch::aarch64::sve::generated | svld4_s8 | function | * [`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`). | |
| 846 | core::core_arch::aarch64::sve::generated | svld4_u16 | function | * [`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`). | |
| 847 | core::core_arch::aarch64::sve::generated | svld4_u32 | function | * [`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`). | |
| 848 | core::core_arch::aarch64::sve::generated | svld4_u64 | function | * [`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`). | |
| 849 | core::core_arch::aarch64::sve::generated | svld4_u8 | function | * [`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`). | |
| 850 | core::core_arch::aarch64::sve::generated | svld4_vnum_f32 | function | * [`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`). | |
| 851 | core::core_arch::aarch64::sve::generated | svld4_vnum_f64 | function | * [`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`). | |
| 852 | core::core_arch::aarch64::sve::generated | svld4_vnum_s16 | function | * [`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`). | |
| 853 | core::core_arch::aarch64::sve::generated | svld4_vnum_s32 | function | * [`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`). | |
| 854 | core::core_arch::aarch64::sve::generated | svld4_vnum_s64 | function | * [`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`). | |
| 855 | core::core_arch::aarch64::sve::generated | svld4_vnum_s8 | function | * [`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`). | |
| 856 | core::core_arch::aarch64::sve::generated | svld4_vnum_u16 | function | * [`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`). | |
| 857 | core::core_arch::aarch64::sve::generated | svld4_vnum_u32 | function | * [`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`). | |
| 858 | core::core_arch::aarch64::sve::generated | svld4_vnum_u64 | function | * [`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`). | |
| 859 | core::core_arch::aarch64::sve::generated | svld4_vnum_u8 | function | * [`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`). | |
| 860 | core::core_arch::aarch64::sve::generated | svldff1_f32 | function | * [`pointer::offset`](pointer#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. | |
| 861 | core::core_arch::aarch64::sve::generated | svldff1_f64 | function | * [`pointer::offset`](pointer#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. | |
| 862 | core::core_arch::aarch64::sve::generated | svldff1_gather_s32index_f32 | function | * [`pointer::offset`](pointer#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. | |
| 863 | core::core_arch::aarch64::sve::generated | svldff1_gather_s32index_s32 | function | * [`pointer::offset`](pointer#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. | |
| 864 | core::core_arch::aarch64::sve::generated | svldff1_gather_s32index_u32 | function | * [`pointer::offset`](pointer#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. | |
| 865 | core::core_arch::aarch64::sve::generated | svldff1_gather_s32offset_f32 | function | * [`pointer::offset`](pointer#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. | |
| 866 | core::core_arch::aarch64::sve::generated | svldff1_gather_s32offset_s32 | function | * [`pointer::offset`](pointer#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. | |
| 867 | core::core_arch::aarch64::sve::generated | svldff1_gather_s32offset_u32 | function | * [`pointer::offset`](pointer#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. | |
| 868 | core::core_arch::aarch64::sve::generated | svldff1_gather_s64index_f64 | function | * [`pointer::offset`](pointer#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. | |
| 869 | core::core_arch::aarch64::sve::generated | svldff1_gather_s64index_s64 | function | * [`pointer::offset`](pointer#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. | |
| 870 | core::core_arch::aarch64::sve::generated | svldff1_gather_s64index_u64 | function | * [`pointer::offset`](pointer#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. | |
| 871 | core::core_arch::aarch64::sve::generated | svldff1_gather_s64offset_f64 | function | * [`pointer::offset`](pointer#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. | |
| 872 | core::core_arch::aarch64::sve::generated | svldff1_gather_s64offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 873 | core::core_arch::aarch64::sve::generated | svldff1_gather_s64offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 874 | core::core_arch::aarch64::sve::generated | svldff1_gather_u32base_f32 | function | * [`pointer::offset`](pointer#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. | |
| 875 | core::core_arch::aarch64::sve::generated | svldff1_gather_u32base_index_f32 | function | * [`pointer::offset`](pointer#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. | |
| 876 | core::core_arch::aarch64::sve::generated | svldff1_gather_u32base_index_s32 | function | * [`pointer::offset`](pointer#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. | |
| 877 | core::core_arch::aarch64::sve::generated | svldff1_gather_u32base_index_u32 | function | * [`pointer::offset`](pointer#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. | |
| 878 | core::core_arch::aarch64::sve::generated | svldff1_gather_u32base_offset_f32 | function | * [`pointer::offset`](pointer#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. | |
| 879 | core::core_arch::aarch64::sve::generated | svldff1_gather_u32base_offset_s32 | function | * [`pointer::offset`](pointer#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. | |
| 880 | core::core_arch::aarch64::sve::generated | svldff1_gather_u32base_offset_u32 | function | * [`pointer::offset`](pointer#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. | |
| 881 | core::core_arch::aarch64::sve::generated | svldff1_gather_u32base_s32 | function | * [`pointer::offset`](pointer#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. | |
| 882 | core::core_arch::aarch64::sve::generated | svldff1_gather_u32base_u32 | function | * [`pointer::offset`](pointer#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. | |
| 883 | core::core_arch::aarch64::sve::generated | svldff1_gather_u32index_f32 | function | * [`pointer::offset`](pointer#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. | |
| 884 | core::core_arch::aarch64::sve::generated | svldff1_gather_u32index_s32 | function | * [`pointer::offset`](pointer#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. | |
| 885 | core::core_arch::aarch64::sve::generated | svldff1_gather_u32index_u32 | function | * [`pointer::offset`](pointer#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. | |
| 886 | core::core_arch::aarch64::sve::generated | svldff1_gather_u32offset_f32 | function | * [`pointer::offset`](pointer#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. | |
| 887 | core::core_arch::aarch64::sve::generated | svldff1_gather_u32offset_s32 | function | * [`pointer::offset`](pointer#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. | |
| 888 | core::core_arch::aarch64::sve::generated | svldff1_gather_u32offset_u32 | function | * [`pointer::offset`](pointer#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. | |
| 889 | core::core_arch::aarch64::sve::generated | svldff1_gather_u64base_f64 | function | * [`pointer::offset`](pointer#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. | |
| 890 | core::core_arch::aarch64::sve::generated | svldff1_gather_u64base_index_f64 | function | * [`pointer::offset`](pointer#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. | |
| 891 | core::core_arch::aarch64::sve::generated | svldff1_gather_u64base_index_s64 | function | * [`pointer::offset`](pointer#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. | |
| 892 | core::core_arch::aarch64::sve::generated | svldff1_gather_u64base_index_u64 | function | * [`pointer::offset`](pointer#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. | |
| 893 | core::core_arch::aarch64::sve::generated | svldff1_gather_u64base_offset_f64 | function | * [`pointer::offset`](pointer#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. | |
| 894 | core::core_arch::aarch64::sve::generated | svldff1_gather_u64base_offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 895 | core::core_arch::aarch64::sve::generated | svldff1_gather_u64base_offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 896 | core::core_arch::aarch64::sve::generated | svldff1_gather_u64base_s64 | function | * [`pointer::offset`](pointer#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. | |
| 897 | core::core_arch::aarch64::sve::generated | svldff1_gather_u64base_u64 | function | * [`pointer::offset`](pointer#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. | |
| 898 | core::core_arch::aarch64::sve::generated | svldff1_gather_u64index_f64 | function | * [`pointer::offset`](pointer#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. | |
| 899 | core::core_arch::aarch64::sve::generated | svldff1_gather_u64index_s64 | function | * [`pointer::offset`](pointer#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. | |
| 900 | core::core_arch::aarch64::sve::generated | svldff1_gather_u64index_u64 | function | * [`pointer::offset`](pointer#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. | |
| 901 | core::core_arch::aarch64::sve::generated | svldff1_gather_u64offset_f64 | function | * [`pointer::offset`](pointer#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. | |
| 902 | core::core_arch::aarch64::sve::generated | svldff1_gather_u64offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 903 | core::core_arch::aarch64::sve::generated | svldff1_gather_u64offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 904 | core::core_arch::aarch64::sve::generated | svldff1_s16 | function | * [`pointer::offset`](pointer#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. | |
| 905 | core::core_arch::aarch64::sve::generated | svldff1_s32 | function | * [`pointer::offset`](pointer#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. | |
| 906 | core::core_arch::aarch64::sve::generated | svldff1_s64 | function | * [`pointer::offset`](pointer#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. | |
| 907 | core::core_arch::aarch64::sve::generated | svldff1_s8 | function | * [`pointer::offset`](pointer#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. | |
| 908 | core::core_arch::aarch64::sve::generated | svldff1_u16 | function | * [`pointer::offset`](pointer#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. | |
| 909 | core::core_arch::aarch64::sve::generated | svldff1_u32 | function | * [`pointer::offset`](pointer#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. | |
| 910 | core::core_arch::aarch64::sve::generated | svldff1_u64 | function | * [`pointer::offset`](pointer#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. | |
| 911 | core::core_arch::aarch64::sve::generated | svldff1_u8 | function | * [`pointer::offset`](pointer#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. | |
| 912 | core::core_arch::aarch64::sve::generated | svldff1_vnum_f32 | function | * [`pointer::offset`](pointer#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. | |
| 913 | core::core_arch::aarch64::sve::generated | svldff1_vnum_f64 | function | * [`pointer::offset`](pointer#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. | |
| 914 | core::core_arch::aarch64::sve::generated | svldff1_vnum_s16 | function | * [`pointer::offset`](pointer#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. | |
| 915 | core::core_arch::aarch64::sve::generated | svldff1_vnum_s32 | function | * [`pointer::offset`](pointer#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. | |
| 916 | core::core_arch::aarch64::sve::generated | svldff1_vnum_s64 | function | * [`pointer::offset`](pointer#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. | |
| 917 | core::core_arch::aarch64::sve::generated | svldff1_vnum_s8 | function | * [`pointer::offset`](pointer#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. | |
| 918 | core::core_arch::aarch64::sve::generated | svldff1_vnum_u16 | function | * [`pointer::offset`](pointer#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. | |
| 919 | core::core_arch::aarch64::sve::generated | svldff1_vnum_u32 | function | * [`pointer::offset`](pointer#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. | |
| 920 | core::core_arch::aarch64::sve::generated | svldff1_vnum_u64 | function | * [`pointer::offset`](pointer#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. | |
| 921 | core::core_arch::aarch64::sve::generated | svldff1_vnum_u8 | function | * [`pointer::offset`](pointer#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. | |
| 922 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_s32offset_s32 | function | * [`pointer::offset`](pointer#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. | |
| 923 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_s32offset_u32 | function | * [`pointer::offset`](pointer#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. | |
| 924 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_s64offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 925 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_s64offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 926 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_u32base_offset_s32 | function | * [`pointer::offset`](pointer#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. | |
| 927 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_u32base_offset_u32 | function | * [`pointer::offset`](pointer#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. | |
| 928 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_u32base_s32 | function | * [`pointer::offset`](pointer#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. | |
| 929 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_u32base_u32 | function | * [`pointer::offset`](pointer#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. | |
| 930 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_u32offset_s32 | function | * [`pointer::offset`](pointer#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. | |
| 931 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_u32offset_u32 | function | * [`pointer::offset`](pointer#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. | |
| 932 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_u64base_offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 933 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_u64base_offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 934 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_u64base_s64 | function | * [`pointer::offset`](pointer#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. | |
| 935 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_u64base_u64 | function | * [`pointer::offset`](pointer#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. | |
| 936 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_u64offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 937 | core::core_arch::aarch64::sve::generated | svldff1sb_gather_u64offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 938 | core::core_arch::aarch64::sve::generated | svldff1sb_s16 | function | * [`pointer::offset`](pointer#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. | |
| 939 | core::core_arch::aarch64::sve::generated | svldff1sb_s32 | function | * [`pointer::offset`](pointer#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. | |
| 940 | core::core_arch::aarch64::sve::generated | svldff1sb_s64 | function | * [`pointer::offset`](pointer#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. | |
| 941 | core::core_arch::aarch64::sve::generated | svldff1sb_u16 | function | * [`pointer::offset`](pointer#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. | |
| 942 | core::core_arch::aarch64::sve::generated | svldff1sb_u32 | function | * [`pointer::offset`](pointer#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. | |
| 943 | core::core_arch::aarch64::sve::generated | svldff1sb_u64 | function | * [`pointer::offset`](pointer#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. | |
| 944 | core::core_arch::aarch64::sve::generated | svldff1sb_vnum_s16 | function | * [`pointer::offset`](pointer#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. | |
| 945 | core::core_arch::aarch64::sve::generated | svldff1sb_vnum_s32 | function | * [`pointer::offset`](pointer#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. | |
| 946 | core::core_arch::aarch64::sve::generated | svldff1sb_vnum_s64 | function | * [`pointer::offset`](pointer#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. | |
| 947 | core::core_arch::aarch64::sve::generated | svldff1sb_vnum_u16 | function | * [`pointer::offset`](pointer#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. | |
| 948 | core::core_arch::aarch64::sve::generated | svldff1sb_vnum_u32 | function | * [`pointer::offset`](pointer#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. | |
| 949 | core::core_arch::aarch64::sve::generated | svldff1sb_vnum_u64 | function | * [`pointer::offset`](pointer#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. | |
| 950 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_s32index_s32 | function | * [`pointer::offset`](pointer#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. | |
| 951 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_s32index_u32 | function | * [`pointer::offset`](pointer#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. | |
| 952 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_s32offset_s32 | function | * [`pointer::offset`](pointer#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. | |
| 953 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_s32offset_u32 | function | * [`pointer::offset`](pointer#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. | |
| 954 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_s64index_s64 | function | * [`pointer::offset`](pointer#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. | |
| 955 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_s64index_u64 | function | * [`pointer::offset`](pointer#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. | |
| 956 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_s64offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 957 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_s64offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 958 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u32base_index_s32 | function | * [`pointer::offset`](pointer#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. | |
| 959 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u32base_index_u32 | function | * [`pointer::offset`](pointer#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. | |
| 960 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u32base_offset_s32 | function | * [`pointer::offset`](pointer#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. | |
| 961 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u32base_offset_u32 | function | * [`pointer::offset`](pointer#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. | |
| 962 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u32base_s32 | function | * [`pointer::offset`](pointer#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. | |
| 963 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u32base_u32 | function | * [`pointer::offset`](pointer#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. | |
| 964 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u32index_s32 | function | * [`pointer::offset`](pointer#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. | |
| 965 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u32index_u32 | function | * [`pointer::offset`](pointer#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. | |
| 966 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u32offset_s32 | function | * [`pointer::offset`](pointer#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. | |
| 967 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u32offset_u32 | function | * [`pointer::offset`](pointer#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. | |
| 968 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u64base_index_s64 | function | * [`pointer::offset`](pointer#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. | |
| 969 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u64base_index_u64 | function | * [`pointer::offset`](pointer#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. | |
| 970 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u64base_offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 971 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u64base_offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 972 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u64base_s64 | function | * [`pointer::offset`](pointer#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. | |
| 973 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u64base_u64 | function | * [`pointer::offset`](pointer#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. | |
| 974 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u64index_s64 | function | * [`pointer::offset`](pointer#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. | |
| 975 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u64index_u64 | function | * [`pointer::offset`](pointer#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. | |
| 976 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u64offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 977 | core::core_arch::aarch64::sve::generated | svldff1sh_gather_u64offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 978 | core::core_arch::aarch64::sve::generated | svldff1sh_s32 | function | * [`pointer::offset`](pointer#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. | |
| 979 | core::core_arch::aarch64::sve::generated | svldff1sh_s64 | function | * [`pointer::offset`](pointer#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. | |
| 980 | core::core_arch::aarch64::sve::generated | svldff1sh_u32 | function | * [`pointer::offset`](pointer#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. | |
| 981 | core::core_arch::aarch64::sve::generated | svldff1sh_u64 | function | * [`pointer::offset`](pointer#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. | |
| 982 | core::core_arch::aarch64::sve::generated | svldff1sh_vnum_s32 | function | * [`pointer::offset`](pointer#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. | |
| 983 | core::core_arch::aarch64::sve::generated | svldff1sh_vnum_s64 | function | * [`pointer::offset`](pointer#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. | |
| 984 | core::core_arch::aarch64::sve::generated | svldff1sh_vnum_u32 | function | * [`pointer::offset`](pointer#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. | |
| 985 | core::core_arch::aarch64::sve::generated | svldff1sh_vnum_u64 | function | * [`pointer::offset`](pointer#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. | |
| 986 | core::core_arch::aarch64::sve::generated | svldff1sw_gather_s64index_s64 | function | * [`pointer::offset`](pointer#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. | |
| 987 | core::core_arch::aarch64::sve::generated | svldff1sw_gather_s64index_u64 | function | * [`pointer::offset`](pointer#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. | |
| 988 | core::core_arch::aarch64::sve::generated | svldff1sw_gather_s64offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 989 | core::core_arch::aarch64::sve::generated | svldff1sw_gather_s64offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 990 | core::core_arch::aarch64::sve::generated | svldff1sw_gather_u64base_index_s64 | function | * [`pointer::offset`](pointer#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. | |
| 991 | core::core_arch::aarch64::sve::generated | svldff1sw_gather_u64base_index_u64 | function | * [`pointer::offset`](pointer#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. | |
| 992 | core::core_arch::aarch64::sve::generated | svldff1sw_gather_u64base_offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 993 | core::core_arch::aarch64::sve::generated | svldff1sw_gather_u64base_offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 994 | core::core_arch::aarch64::sve::generated | svldff1sw_gather_u64base_s64 | function | * [`pointer::offset`](pointer#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. | |
| 995 | core::core_arch::aarch64::sve::generated | svldff1sw_gather_u64base_u64 | function | * [`pointer::offset`](pointer#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. | |
| 996 | core::core_arch::aarch64::sve::generated | svldff1sw_gather_u64index_s64 | function | * [`pointer::offset`](pointer#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. | |
| 997 | core::core_arch::aarch64::sve::generated | svldff1sw_gather_u64index_u64 | function | * [`pointer::offset`](pointer#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. | |
| 998 | core::core_arch::aarch64::sve::generated | svldff1sw_gather_u64offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 999 | core::core_arch::aarch64::sve::generated | svldff1sw_gather_u64offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1000 | core::core_arch::aarch64::sve::generated | svldff1sw_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1001 | core::core_arch::aarch64::sve::generated | svldff1sw_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1002 | core::core_arch::aarch64::sve::generated | svldff1sw_vnum_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1003 | core::core_arch::aarch64::sve::generated | svldff1sw_vnum_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1004 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_s32offset_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1005 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_s32offset_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1006 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_s64offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1007 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_s64offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1008 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_u32base_offset_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1009 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_u32base_offset_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1010 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_u32base_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1011 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_u32base_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1012 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_u32offset_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1013 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_u32offset_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1014 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_u64base_offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1015 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_u64base_offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1016 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_u64base_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1017 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_u64base_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1018 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_u64offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1019 | core::core_arch::aarch64::sve::generated | svldff1ub_gather_u64offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1020 | core::core_arch::aarch64::sve::generated | svldff1ub_s16 | function | * [`pointer::offset`](pointer#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. | |
| 1021 | core::core_arch::aarch64::sve::generated | svldff1ub_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1022 | core::core_arch::aarch64::sve::generated | svldff1ub_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1023 | core::core_arch::aarch64::sve::generated | svldff1ub_u16 | function | * [`pointer::offset`](pointer#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. | |
| 1024 | core::core_arch::aarch64::sve::generated | svldff1ub_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1025 | core::core_arch::aarch64::sve::generated | svldff1ub_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1026 | core::core_arch::aarch64::sve::generated | svldff1ub_vnum_s16 | function | * [`pointer::offset`](pointer#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. | |
| 1027 | core::core_arch::aarch64::sve::generated | svldff1ub_vnum_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1028 | core::core_arch::aarch64::sve::generated | svldff1ub_vnum_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1029 | core::core_arch::aarch64::sve::generated | svldff1ub_vnum_u16 | function | * [`pointer::offset`](pointer#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. | |
| 1030 | core::core_arch::aarch64::sve::generated | svldff1ub_vnum_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1031 | core::core_arch::aarch64::sve::generated | svldff1ub_vnum_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1032 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_s32index_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1033 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_s32index_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1034 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_s32offset_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1035 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_s32offset_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1036 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_s64index_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1037 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_s64index_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1038 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_s64offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1039 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_s64offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1040 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u32base_index_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1041 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u32base_index_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1042 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u32base_offset_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1043 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u32base_offset_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1044 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u32base_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1045 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u32base_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1046 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u32index_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1047 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u32index_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1048 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u32offset_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1049 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u32offset_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1050 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u64base_index_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1051 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u64base_index_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1052 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u64base_offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1053 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u64base_offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1054 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u64base_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1055 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u64base_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1056 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u64index_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1057 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u64index_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1058 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u64offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1059 | core::core_arch::aarch64::sve::generated | svldff1uh_gather_u64offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1060 | core::core_arch::aarch64::sve::generated | svldff1uh_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1061 | core::core_arch::aarch64::sve::generated | svldff1uh_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1062 | core::core_arch::aarch64::sve::generated | svldff1uh_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1063 | core::core_arch::aarch64::sve::generated | svldff1uh_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1064 | core::core_arch::aarch64::sve::generated | svldff1uh_vnum_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1065 | core::core_arch::aarch64::sve::generated | svldff1uh_vnum_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1066 | core::core_arch::aarch64::sve::generated | svldff1uh_vnum_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1067 | core::core_arch::aarch64::sve::generated | svldff1uh_vnum_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1068 | core::core_arch::aarch64::sve::generated | svldff1uw_gather_s64index_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1069 | core::core_arch::aarch64::sve::generated | svldff1uw_gather_s64index_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1070 | core::core_arch::aarch64::sve::generated | svldff1uw_gather_s64offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1071 | core::core_arch::aarch64::sve::generated | svldff1uw_gather_s64offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1072 | core::core_arch::aarch64::sve::generated | svldff1uw_gather_u64base_index_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1073 | core::core_arch::aarch64::sve::generated | svldff1uw_gather_u64base_index_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1074 | core::core_arch::aarch64::sve::generated | svldff1uw_gather_u64base_offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1075 | core::core_arch::aarch64::sve::generated | svldff1uw_gather_u64base_offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1076 | core::core_arch::aarch64::sve::generated | svldff1uw_gather_u64base_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1077 | core::core_arch::aarch64::sve::generated | svldff1uw_gather_u64base_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1078 | core::core_arch::aarch64::sve::generated | svldff1uw_gather_u64index_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1079 | core::core_arch::aarch64::sve::generated | svldff1uw_gather_u64index_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1080 | core::core_arch::aarch64::sve::generated | svldff1uw_gather_u64offset_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1081 | core::core_arch::aarch64::sve::generated | svldff1uw_gather_u64offset_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1082 | core::core_arch::aarch64::sve::generated | svldff1uw_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1083 | core::core_arch::aarch64::sve::generated | svldff1uw_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1084 | core::core_arch::aarch64::sve::generated | svldff1uw_vnum_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1085 | core::core_arch::aarch64::sve::generated | svldff1uw_vnum_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1086 | core::core_arch::aarch64::sve::generated | svldnf1_f32 | function | * [`pointer::offset`](pointer#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. | |
| 1087 | core::core_arch::aarch64::sve::generated | svldnf1_f64 | function | * [`pointer::offset`](pointer#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. | |
| 1088 | core::core_arch::aarch64::sve::generated | svldnf1_s16 | function | * [`pointer::offset`](pointer#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. | |
| 1089 | core::core_arch::aarch64::sve::generated | svldnf1_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1090 | core::core_arch::aarch64::sve::generated | svldnf1_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1091 | core::core_arch::aarch64::sve::generated | svldnf1_s8 | function | * [`pointer::offset`](pointer#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. | |
| 1092 | core::core_arch::aarch64::sve::generated | svldnf1_u16 | function | * [`pointer::offset`](pointer#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. | |
| 1093 | core::core_arch::aarch64::sve::generated | svldnf1_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1094 | core::core_arch::aarch64::sve::generated | svldnf1_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1095 | core::core_arch::aarch64::sve::generated | svldnf1_u8 | function | * [`pointer::offset`](pointer#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. | |
| 1096 | core::core_arch::aarch64::sve::generated | svldnf1_vnum_f32 | function | * [`pointer::offset`](pointer#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. | |
| 1097 | core::core_arch::aarch64::sve::generated | svldnf1_vnum_f64 | function | * [`pointer::offset`](pointer#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. | |
| 1098 | core::core_arch::aarch64::sve::generated | svldnf1_vnum_s16 | function | * [`pointer::offset`](pointer#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. | |
| 1099 | core::core_arch::aarch64::sve::generated | svldnf1_vnum_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1100 | core::core_arch::aarch64::sve::generated | svldnf1_vnum_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1101 | core::core_arch::aarch64::sve::generated | svldnf1_vnum_s8 | function | * [`pointer::offset`](pointer#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. | |
| 1102 | core::core_arch::aarch64::sve::generated | svldnf1_vnum_u16 | function | * [`pointer::offset`](pointer#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. | |
| 1103 | core::core_arch::aarch64::sve::generated | svldnf1_vnum_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1104 | core::core_arch::aarch64::sve::generated | svldnf1_vnum_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1105 | core::core_arch::aarch64::sve::generated | svldnf1_vnum_u8 | function | * [`pointer::offset`](pointer#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. | |
| 1106 | core::core_arch::aarch64::sve::generated | svldnf1sb_s16 | function | * [`pointer::offset`](pointer#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. | |
| 1107 | core::core_arch::aarch64::sve::generated | svldnf1sb_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1108 | core::core_arch::aarch64::sve::generated | svldnf1sb_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1109 | core::core_arch::aarch64::sve::generated | svldnf1sb_u16 | function | * [`pointer::offset`](pointer#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. | |
| 1110 | core::core_arch::aarch64::sve::generated | svldnf1sb_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1111 | core::core_arch::aarch64::sve::generated | svldnf1sb_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1112 | core::core_arch::aarch64::sve::generated | svldnf1sb_vnum_s16 | function | * [`pointer::offset`](pointer#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. | |
| 1113 | core::core_arch::aarch64::sve::generated | svldnf1sb_vnum_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1114 | core::core_arch::aarch64::sve::generated | svldnf1sb_vnum_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1115 | core::core_arch::aarch64::sve::generated | svldnf1sb_vnum_u16 | function | * [`pointer::offset`](pointer#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. | |
| 1116 | core::core_arch::aarch64::sve::generated | svldnf1sb_vnum_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1117 | core::core_arch::aarch64::sve::generated | svldnf1sb_vnum_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1118 | core::core_arch::aarch64::sve::generated | svldnf1sh_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1119 | core::core_arch::aarch64::sve::generated | svldnf1sh_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1120 | core::core_arch::aarch64::sve::generated | svldnf1sh_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1121 | core::core_arch::aarch64::sve::generated | svldnf1sh_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1122 | core::core_arch::aarch64::sve::generated | svldnf1sh_vnum_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1123 | core::core_arch::aarch64::sve::generated | svldnf1sh_vnum_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1124 | core::core_arch::aarch64::sve::generated | svldnf1sh_vnum_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1125 | core::core_arch::aarch64::sve::generated | svldnf1sh_vnum_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1126 | core::core_arch::aarch64::sve::generated | svldnf1sw_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1127 | core::core_arch::aarch64::sve::generated | svldnf1sw_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1128 | core::core_arch::aarch64::sve::generated | svldnf1sw_vnum_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1129 | core::core_arch::aarch64::sve::generated | svldnf1sw_vnum_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1130 | core::core_arch::aarch64::sve::generated | svldnf1ub_s16 | function | * [`pointer::offset`](pointer#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. | |
| 1131 | core::core_arch::aarch64::sve::generated | svldnf1ub_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1132 | core::core_arch::aarch64::sve::generated | svldnf1ub_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1133 | core::core_arch::aarch64::sve::generated | svldnf1ub_u16 | function | * [`pointer::offset`](pointer#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. | |
| 1134 | core::core_arch::aarch64::sve::generated | svldnf1ub_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1135 | core::core_arch::aarch64::sve::generated | svldnf1ub_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1136 | core::core_arch::aarch64::sve::generated | svldnf1ub_vnum_s16 | function | * [`pointer::offset`](pointer#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. | |
| 1137 | core::core_arch::aarch64::sve::generated | svldnf1ub_vnum_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1138 | core::core_arch::aarch64::sve::generated | svldnf1ub_vnum_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1139 | core::core_arch::aarch64::sve::generated | svldnf1ub_vnum_u16 | function | * [`pointer::offset`](pointer#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. | |
| 1140 | core::core_arch::aarch64::sve::generated | svldnf1ub_vnum_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1141 | core::core_arch::aarch64::sve::generated | svldnf1ub_vnum_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1142 | core::core_arch::aarch64::sve::generated | svldnf1uh_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1143 | core::core_arch::aarch64::sve::generated | svldnf1uh_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1144 | core::core_arch::aarch64::sve::generated | svldnf1uh_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1145 | core::core_arch::aarch64::sve::generated | svldnf1uh_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1146 | core::core_arch::aarch64::sve::generated | svldnf1uh_vnum_s32 | function | * [`pointer::offset`](pointer#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. | |
| 1147 | core::core_arch::aarch64::sve::generated | svldnf1uh_vnum_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1148 | core::core_arch::aarch64::sve::generated | svldnf1uh_vnum_u32 | function | * [`pointer::offset`](pointer#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. | |
| 1149 | core::core_arch::aarch64::sve::generated | svldnf1uh_vnum_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1150 | core::core_arch::aarch64::sve::generated | svldnf1uw_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1151 | core::core_arch::aarch64::sve::generated | svldnf1uw_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1152 | core::core_arch::aarch64::sve::generated | svldnf1uw_vnum_s64 | function | * [`pointer::offset`](pointer#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. | |
| 1153 | core::core_arch::aarch64::sve::generated | svldnf1uw_vnum_u64 | function | * [`pointer::offset`](pointer#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. | |
| 1154 | core::core_arch::aarch64::sve::generated | svldnt1_f32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1155 | core::core_arch::aarch64::sve::generated | svldnt1_f64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1156 | core::core_arch::aarch64::sve::generated | svldnt1_s16 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1157 | core::core_arch::aarch64::sve::generated | svldnt1_s32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1158 | core::core_arch::aarch64::sve::generated | svldnt1_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1159 | core::core_arch::aarch64::sve::generated | svldnt1_s8 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1160 | core::core_arch::aarch64::sve::generated | svldnt1_u16 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1161 | core::core_arch::aarch64::sve::generated | svldnt1_u32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1162 | core::core_arch::aarch64::sve::generated | svldnt1_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1163 | core::core_arch::aarch64::sve::generated | svldnt1_u8 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1164 | core::core_arch::aarch64::sve::generated | svldnt1_vnum_f32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1165 | core::core_arch::aarch64::sve::generated | svldnt1_vnum_f64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1166 | core::core_arch::aarch64::sve::generated | svldnt1_vnum_s16 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1167 | core::core_arch::aarch64::sve::generated | svldnt1_vnum_s32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1168 | core::core_arch::aarch64::sve::generated | svldnt1_vnum_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1169 | core::core_arch::aarch64::sve::generated | svldnt1_vnum_s8 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1170 | core::core_arch::aarch64::sve::generated | svldnt1_vnum_u16 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1171 | core::core_arch::aarch64::sve::generated | svldnt1_vnum_u32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1172 | core::core_arch::aarch64::sve::generated | svldnt1_vnum_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1173 | core::core_arch::aarch64::sve::generated | svldnt1_vnum_u8 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1174 | core::core_arch::aarch64::sve::generated | svprfb | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1175 | core::core_arch::aarch64::sve::generated | svprfb_gather_s32offset | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1176 | core::core_arch::aarch64::sve::generated | svprfb_gather_s64offset | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1177 | core::core_arch::aarch64::sve::generated | svprfb_gather_u32base | function | * [`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. | |
| 1178 | core::core_arch::aarch64::sve::generated | svprfb_gather_u32base_offset | function | * [`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. | |
| 1179 | core::core_arch::aarch64::sve::generated | svprfb_gather_u32offset | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1180 | core::core_arch::aarch64::sve::generated | svprfb_gather_u64base | function | * [`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. | |
| 1181 | core::core_arch::aarch64::sve::generated | svprfb_gather_u64base_offset | function | * [`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. | |
| 1182 | core::core_arch::aarch64::sve::generated | svprfb_gather_u64offset | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1183 | core::core_arch::aarch64::sve::generated | svprfb_vnum | function | * [`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. | |
| 1184 | core::core_arch::aarch64::sve::generated | svprfd | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1185 | core::core_arch::aarch64::sve::generated | svprfd_gather_s32index | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1186 | core::core_arch::aarch64::sve::generated | svprfd_gather_s64index | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1187 | core::core_arch::aarch64::sve::generated | svprfd_gather_u32base | function | * [`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. | |
| 1188 | core::core_arch::aarch64::sve::generated | svprfd_gather_u32base_index | function | * [`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. | |
| 1189 | core::core_arch::aarch64::sve::generated | svprfd_gather_u32index | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1190 | core::core_arch::aarch64::sve::generated | svprfd_gather_u64base | function | * [`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. | |
| 1191 | core::core_arch::aarch64::sve::generated | svprfd_gather_u64base_index | function | * [`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. | |
| 1192 | core::core_arch::aarch64::sve::generated | svprfd_gather_u64index | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1193 | core::core_arch::aarch64::sve::generated | svprfd_vnum | function | * [`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. | |
| 1194 | core::core_arch::aarch64::sve::generated | svprfh | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1195 | core::core_arch::aarch64::sve::generated | svprfh_gather_s32index | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1196 | core::core_arch::aarch64::sve::generated | svprfh_gather_s64index | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1197 | core::core_arch::aarch64::sve::generated | svprfh_gather_u32base | function | * [`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. | |
| 1198 | core::core_arch::aarch64::sve::generated | svprfh_gather_u32base_index | function | * [`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. | |
| 1199 | core::core_arch::aarch64::sve::generated | svprfh_gather_u32index | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1200 | core::core_arch::aarch64::sve::generated | svprfh_gather_u64base | function | * [`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. | |
| 1201 | core::core_arch::aarch64::sve::generated | svprfh_gather_u64base_index | function | * [`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. | |
| 1202 | core::core_arch::aarch64::sve::generated | svprfh_gather_u64index | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1203 | core::core_arch::aarch64::sve::generated | svprfh_vnum | function | * [`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. | |
| 1204 | core::core_arch::aarch64::sve::generated | svprfw | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1205 | core::core_arch::aarch64::sve::generated | svprfw_gather_s32index | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1206 | core::core_arch::aarch64::sve::generated | svprfw_gather_s64index | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1207 | core::core_arch::aarch64::sve::generated | svprfw_gather_u32base | function | * [`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. | |
| 1208 | core::core_arch::aarch64::sve::generated | svprfw_gather_u32base_index | function | * [`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. | |
| 1209 | core::core_arch::aarch64::sve::generated | svprfw_gather_u32index | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1210 | core::core_arch::aarch64::sve::generated | svprfw_gather_u64base | function | * [`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. | |
| 1211 | core::core_arch::aarch64::sve::generated | svprfw_gather_u64base_index | function | * [`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. | |
| 1212 | core::core_arch::aarch64::sve::generated | svprfw_gather_u64index | function | * [`pointer::offset`](pointer#method.offset) safety constraints must be met for the address calculation for each active element (governed by `pg`). | |
| 1213 | core::core_arch::aarch64::sve::generated | svprfw_vnum | function | * [`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. | |
| 1214 | core::core_arch::aarch64::sve::generated | svst1_f32 | function | * [`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`). | |
| 1215 | core::core_arch::aarch64::sve::generated | svst1_f64 | function | * [`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`). | |
| 1216 | core::core_arch::aarch64::sve::generated | svst1_s16 | function | * [`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`). | |
| 1217 | core::core_arch::aarch64::sve::generated | svst1_s32 | function | * [`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`). | |
| 1218 | core::core_arch::aarch64::sve::generated | svst1_s64 | function | * [`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`). | |
| 1219 | core::core_arch::aarch64::sve::generated | svst1_s8 | function | * [`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`). | |
| 1220 | core::core_arch::aarch64::sve::generated | svst1_scatter_s32index_f32 | function | * [`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`). | |
| 1221 | core::core_arch::aarch64::sve::generated | svst1_scatter_s32index_s32 | function | * [`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`). | |
| 1222 | core::core_arch::aarch64::sve::generated | svst1_scatter_s32index_u32 | function | * [`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`). | |
| 1223 | core::core_arch::aarch64::sve::generated | svst1_scatter_s32offset_f32 | function | * [`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`). | |
| 1224 | core::core_arch::aarch64::sve::generated | svst1_scatter_s32offset_s32 | function | * [`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`). | |
| 1225 | core::core_arch::aarch64::sve::generated | svst1_scatter_s32offset_u32 | function | * [`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`). | |
| 1226 | core::core_arch::aarch64::sve::generated | svst1_scatter_s64index_f64 | function | * [`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`). | |
| 1227 | core::core_arch::aarch64::sve::generated | svst1_scatter_s64index_s64 | function | * [`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`). | |
| 1228 | core::core_arch::aarch64::sve::generated | svst1_scatter_s64index_u64 | function | * [`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`). | |
| 1229 | core::core_arch::aarch64::sve::generated | svst1_scatter_s64offset_f64 | function | * [`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`). | |
| 1230 | core::core_arch::aarch64::sve::generated | svst1_scatter_s64offset_s64 | function | * [`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`). | |
| 1231 | core::core_arch::aarch64::sve::generated | svst1_scatter_s64offset_u64 | function | * [`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`). | |
| 1232 | core::core_arch::aarch64::sve::generated | svst1_scatter_u32base_f32 | function | * [`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. | |
| 1233 | core::core_arch::aarch64::sve::generated | svst1_scatter_u32base_index_f32 | function | * [`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. | |
| 1234 | core::core_arch::aarch64::sve::generated | svst1_scatter_u32base_index_s32 | function | * [`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. | |
| 1235 | core::core_arch::aarch64::sve::generated | svst1_scatter_u32base_index_u32 | function | * [`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. | |
| 1236 | core::core_arch::aarch64::sve::generated | svst1_scatter_u32base_offset_f32 | function | * [`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. | |
| 1237 | core::core_arch::aarch64::sve::generated | svst1_scatter_u32base_offset_s32 | function | * [`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. | |
| 1238 | core::core_arch::aarch64::sve::generated | svst1_scatter_u32base_offset_u32 | function | * [`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. | |
| 1239 | core::core_arch::aarch64::sve::generated | svst1_scatter_u32base_s32 | function | * [`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. | |
| 1240 | core::core_arch::aarch64::sve::generated | svst1_scatter_u32base_u32 | function | * [`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. | |
| 1241 | core::core_arch::aarch64::sve::generated | svst1_scatter_u32index_f32 | function | * [`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`). | |
| 1242 | core::core_arch::aarch64::sve::generated | svst1_scatter_u32index_s32 | function | * [`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`). | |
| 1243 | core::core_arch::aarch64::sve::generated | svst1_scatter_u32index_u32 | function | * [`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`). | |
| 1244 | core::core_arch::aarch64::sve::generated | svst1_scatter_u32offset_f32 | function | * [`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`). | |
| 1245 | core::core_arch::aarch64::sve::generated | svst1_scatter_u32offset_s32 | function | * [`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`). | |
| 1246 | core::core_arch::aarch64::sve::generated | svst1_scatter_u32offset_u32 | function | * [`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`). | |
| 1247 | core::core_arch::aarch64::sve::generated | svst1_scatter_u64base_f64 | function | * [`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. | |
| 1248 | core::core_arch::aarch64::sve::generated | svst1_scatter_u64base_index_f64 | function | * [`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. | |
| 1249 | core::core_arch::aarch64::sve::generated | svst1_scatter_u64base_index_s64 | function | * [`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. | |
| 1250 | core::core_arch::aarch64::sve::generated | svst1_scatter_u64base_index_u64 | function | * [`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. | |
| 1251 | core::core_arch::aarch64::sve::generated | svst1_scatter_u64base_offset_f64 | function | * [`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. | |
| 1252 | core::core_arch::aarch64::sve::generated | svst1_scatter_u64base_offset_s64 | function | * [`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. | |
| 1253 | core::core_arch::aarch64::sve::generated | svst1_scatter_u64base_offset_u64 | function | * [`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. | |
| 1254 | core::core_arch::aarch64::sve::generated | svst1_scatter_u64base_s64 | function | * [`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. | |
| 1255 | core::core_arch::aarch64::sve::generated | svst1_scatter_u64base_u64 | function | * [`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. | |
| 1256 | core::core_arch::aarch64::sve::generated | svst1_scatter_u64index_f64 | function | * [`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`). | |
| 1257 | core::core_arch::aarch64::sve::generated | svst1_scatter_u64index_s64 | function | * [`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`). | |
| 1258 | core::core_arch::aarch64::sve::generated | svst1_scatter_u64index_u64 | function | * [`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`). | |
| 1259 | core::core_arch::aarch64::sve::generated | svst1_scatter_u64offset_f64 | function | * [`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`). | |
| 1260 | core::core_arch::aarch64::sve::generated | svst1_scatter_u64offset_s64 | function | * [`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`). | |
| 1261 | core::core_arch::aarch64::sve::generated | svst1_scatter_u64offset_u64 | function | * [`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`). | |
| 1262 | core::core_arch::aarch64::sve::generated | svst1_u16 | function | * [`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`). | |
| 1263 | core::core_arch::aarch64::sve::generated | svst1_u32 | function | * [`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`). | |
| 1264 | core::core_arch::aarch64::sve::generated | svst1_u64 | function | * [`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`). | |
| 1265 | core::core_arch::aarch64::sve::generated | svst1_u8 | function | * [`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`). | |
| 1266 | core::core_arch::aarch64::sve::generated | svst1_vnum_f32 | function | * [`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`). | |
| 1267 | core::core_arch::aarch64::sve::generated | svst1_vnum_f64 | function | * [`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`). | |
| 1268 | core::core_arch::aarch64::sve::generated | svst1_vnum_s16 | function | * [`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`). | |
| 1269 | core::core_arch::aarch64::sve::generated | svst1_vnum_s32 | function | * [`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`). | |
| 1270 | core::core_arch::aarch64::sve::generated | svst1_vnum_s64 | function | * [`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`). | |
| 1271 | core::core_arch::aarch64::sve::generated | svst1_vnum_s8 | function | * [`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`). | |
| 1272 | core::core_arch::aarch64::sve::generated | svst1_vnum_u16 | function | * [`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`). | |
| 1273 | core::core_arch::aarch64::sve::generated | svst1_vnum_u32 | function | * [`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`). | |
| 1274 | core::core_arch::aarch64::sve::generated | svst1_vnum_u64 | function | * [`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`). | |
| 1275 | core::core_arch::aarch64::sve::generated | svst1_vnum_u8 | function | * [`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`). | |
| 1276 | core::core_arch::aarch64::sve::generated | svst1b_s16 | function | * [`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`). | |
| 1277 | core::core_arch::aarch64::sve::generated | svst1b_s32 | function | * [`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`). | |
| 1278 | core::core_arch::aarch64::sve::generated | svst1b_s64 | function | * [`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`). | |
| 1279 | core::core_arch::aarch64::sve::generated | svst1b_scatter_s32offset_s32 | function | * [`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`). | |
| 1280 | core::core_arch::aarch64::sve::generated | svst1b_scatter_s32offset_u32 | function | * [`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`). | |
| 1281 | core::core_arch::aarch64::sve::generated | svst1b_scatter_s64offset_s64 | function | * [`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`). | |
| 1282 | core::core_arch::aarch64::sve::generated | svst1b_scatter_s64offset_u64 | function | * [`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`). | |
| 1283 | core::core_arch::aarch64::sve::generated | svst1b_scatter_u32base_offset_s32 | function | * [`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. | |
| 1284 | core::core_arch::aarch64::sve::generated | svst1b_scatter_u32base_offset_u32 | function | * [`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. | |
| 1285 | core::core_arch::aarch64::sve::generated | svst1b_scatter_u32base_s32 | function | * [`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. | |
| 1286 | core::core_arch::aarch64::sve::generated | svst1b_scatter_u32base_u32 | function | * [`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. | |
| 1287 | core::core_arch::aarch64::sve::generated | svst1b_scatter_u32offset_s32 | function | * [`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`). | |
| 1288 | core::core_arch::aarch64::sve::generated | svst1b_scatter_u32offset_u32 | function | * [`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`). | |
| 1289 | core::core_arch::aarch64::sve::generated | svst1b_scatter_u64base_offset_s64 | function | * [`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. | |
| 1290 | core::core_arch::aarch64::sve::generated | svst1b_scatter_u64base_offset_u64 | function | * [`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. | |
| 1291 | core::core_arch::aarch64::sve::generated | svst1b_scatter_u64base_s64 | function | * [`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. | |
| 1292 | core::core_arch::aarch64::sve::generated | svst1b_scatter_u64base_u64 | function | * [`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. | |
| 1293 | core::core_arch::aarch64::sve::generated | svst1b_scatter_u64offset_s64 | function | * [`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`). | |
| 1294 | core::core_arch::aarch64::sve::generated | svst1b_scatter_u64offset_u64 | function | * [`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`). | |
| 1295 | core::core_arch::aarch64::sve::generated | svst1b_u16 | function | * [`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`). | |
| 1296 | core::core_arch::aarch64::sve::generated | svst1b_u32 | function | * [`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`). | |
| 1297 | core::core_arch::aarch64::sve::generated | svst1b_u64 | function | * [`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`). | |
| 1298 | core::core_arch::aarch64::sve::generated | svst1b_vnum_s16 | function | * [`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`). | |
| 1299 | core::core_arch::aarch64::sve::generated | svst1b_vnum_s32 | function | * [`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`). | |
| 1300 | core::core_arch::aarch64::sve::generated | svst1b_vnum_s64 | function | * [`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`). | |
| 1301 | core::core_arch::aarch64::sve::generated | svst1b_vnum_u16 | function | * [`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`). | |
| 1302 | core::core_arch::aarch64::sve::generated | svst1b_vnum_u32 | function | * [`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`). | |
| 1303 | core::core_arch::aarch64::sve::generated | svst1b_vnum_u64 | function | * [`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`). | |
| 1304 | core::core_arch::aarch64::sve::generated | svst1h_s32 | function | * [`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`). | |
| 1305 | core::core_arch::aarch64::sve::generated | svst1h_s64 | function | * [`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`). | |
| 1306 | core::core_arch::aarch64::sve::generated | svst1h_scatter_s32index_s32 | function | * [`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`). | |
| 1307 | core::core_arch::aarch64::sve::generated | svst1h_scatter_s32index_u32 | function | * [`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`). | |
| 1308 | core::core_arch::aarch64::sve::generated | svst1h_scatter_s32offset_s32 | function | * [`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`). | |
| 1309 | core::core_arch::aarch64::sve::generated | svst1h_scatter_s32offset_u32 | function | * [`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`). | |
| 1310 | core::core_arch::aarch64::sve::generated | svst1h_scatter_s64index_s64 | function | * [`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`). | |
| 1311 | core::core_arch::aarch64::sve::generated | svst1h_scatter_s64index_u64 | function | * [`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`). | |
| 1312 | core::core_arch::aarch64::sve::generated | svst1h_scatter_s64offset_s64 | function | * [`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`). | |
| 1313 | core::core_arch::aarch64::sve::generated | svst1h_scatter_s64offset_u64 | function | * [`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`). | |
| 1314 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u32base_index_s32 | function | * [`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. | |
| 1315 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u32base_index_u32 | function | * [`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. | |
| 1316 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u32base_offset_s32 | function | * [`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. | |
| 1317 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u32base_offset_u32 | function | * [`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. | |
| 1318 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u32base_s32 | function | * [`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. | |
| 1319 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u32base_u32 | function | * [`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. | |
| 1320 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u32index_s32 | function | * [`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`). | |
| 1321 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u32index_u32 | function | * [`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`). | |
| 1322 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u32offset_s32 | function | * [`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`). | |
| 1323 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u32offset_u32 | function | * [`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`). | |
| 1324 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u64base_index_s64 | function | * [`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. | |
| 1325 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u64base_index_u64 | function | * [`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. | |
| 1326 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u64base_offset_s64 | function | * [`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. | |
| 1327 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u64base_offset_u64 | function | * [`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. | |
| 1328 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u64base_s64 | function | * [`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. | |
| 1329 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u64base_u64 | function | * [`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. | |
| 1330 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u64index_s64 | function | * [`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`). | |
| 1331 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u64index_u64 | function | * [`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`). | |
| 1332 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u64offset_s64 | function | * [`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`). | |
| 1333 | core::core_arch::aarch64::sve::generated | svst1h_scatter_u64offset_u64 | function | * [`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`). | |
| 1334 | core::core_arch::aarch64::sve::generated | svst1h_u32 | function | * [`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`). | |
| 1335 | core::core_arch::aarch64::sve::generated | svst1h_u64 | function | * [`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`). | |
| 1336 | core::core_arch::aarch64::sve::generated | svst1h_vnum_s32 | function | * [`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`). | |
| 1337 | core::core_arch::aarch64::sve::generated | svst1h_vnum_s64 | function | * [`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`). | |
| 1338 | core::core_arch::aarch64::sve::generated | svst1h_vnum_u32 | function | * [`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`). | |
| 1339 | core::core_arch::aarch64::sve::generated | svst1h_vnum_u64 | function | * [`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`). | |
| 1340 | core::core_arch::aarch64::sve::generated | svst1w_s64 | function | * [`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`). | |
| 1341 | core::core_arch::aarch64::sve::generated | svst1w_scatter_s64index_s64 | function | * [`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`). | |
| 1342 | core::core_arch::aarch64::sve::generated | svst1w_scatter_s64index_u64 | function | * [`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`). | |
| 1343 | core::core_arch::aarch64::sve::generated | svst1w_scatter_s64offset_s64 | function | * [`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`). | |
| 1344 | core::core_arch::aarch64::sve::generated | svst1w_scatter_s64offset_u64 | function | * [`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`). | |
| 1345 | core::core_arch::aarch64::sve::generated | svst1w_scatter_u64base_index_s64 | function | * [`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. | |
| 1346 | core::core_arch::aarch64::sve::generated | svst1w_scatter_u64base_index_u64 | function | * [`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. | |
| 1347 | core::core_arch::aarch64::sve::generated | svst1w_scatter_u64base_offset_s64 | function | * [`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. | |
| 1348 | core::core_arch::aarch64::sve::generated | svst1w_scatter_u64base_offset_u64 | function | * [`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. | |
| 1349 | core::core_arch::aarch64::sve::generated | svst1w_scatter_u64base_s64 | function | * [`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. | |
| 1350 | core::core_arch::aarch64::sve::generated | svst1w_scatter_u64base_u64 | function | * [`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. | |
| 1351 | core::core_arch::aarch64::sve::generated | svst1w_scatter_u64index_s64 | function | * [`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`). | |
| 1352 | core::core_arch::aarch64::sve::generated | svst1w_scatter_u64index_u64 | function | * [`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`). | |
| 1353 | core::core_arch::aarch64::sve::generated | svst1w_scatter_u64offset_s64 | function | * [`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`). | |
| 1354 | core::core_arch::aarch64::sve::generated | svst1w_scatter_u64offset_u64 | function | * [`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`). | |
| 1355 | core::core_arch::aarch64::sve::generated | svst1w_u64 | function | * [`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`). | |
| 1356 | core::core_arch::aarch64::sve::generated | svst1w_vnum_s64 | function | * [`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`). | |
| 1357 | core::core_arch::aarch64::sve::generated | svst1w_vnum_u64 | function | * [`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`). | |
| 1358 | core::core_arch::aarch64::sve::generated | svst2_f32 | function | * [`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`). | |
| 1359 | core::core_arch::aarch64::sve::generated | svst2_f64 | function | * [`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`). | |
| 1360 | core::core_arch::aarch64::sve::generated | svst2_s16 | function | * [`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`). | |
| 1361 | core::core_arch::aarch64::sve::generated | svst2_s32 | function | * [`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`). | |
| 1362 | core::core_arch::aarch64::sve::generated | svst2_s64 | function | * [`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`). | |
| 1363 | core::core_arch::aarch64::sve::generated | svst2_s8 | function | * [`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`). | |
| 1364 | core::core_arch::aarch64::sve::generated | svst2_u16 | function | * [`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`). | |
| 1365 | core::core_arch::aarch64::sve::generated | svst2_u32 | function | * [`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`). | |
| 1366 | core::core_arch::aarch64::sve::generated | svst2_u64 | function | * [`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`). | |
| 1367 | core::core_arch::aarch64::sve::generated | svst2_u8 | function | * [`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`). | |
| 1368 | core::core_arch::aarch64::sve::generated | svst2_vnum_f32 | function | * [`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`). | |
| 1369 | core::core_arch::aarch64::sve::generated | svst2_vnum_f64 | function | * [`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`). | |
| 1370 | core::core_arch::aarch64::sve::generated | svst2_vnum_s16 | function | * [`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`). | |
| 1371 | core::core_arch::aarch64::sve::generated | svst2_vnum_s32 | function | * [`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`). | |
| 1372 | core::core_arch::aarch64::sve::generated | svst2_vnum_s64 | function | * [`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`). | |
| 1373 | core::core_arch::aarch64::sve::generated | svst2_vnum_s8 | function | * [`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`). | |
| 1374 | core::core_arch::aarch64::sve::generated | svst2_vnum_u16 | function | * [`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`). | |
| 1375 | core::core_arch::aarch64::sve::generated | svst2_vnum_u32 | function | * [`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`). | |
| 1376 | core::core_arch::aarch64::sve::generated | svst2_vnum_u64 | function | * [`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`). | |
| 1377 | core::core_arch::aarch64::sve::generated | svst2_vnum_u8 | function | * [`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`). | |
| 1378 | core::core_arch::aarch64::sve::generated | svst3_f32 | function | * [`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`). | |
| 1379 | core::core_arch::aarch64::sve::generated | svst3_f64 | function | * [`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`). | |
| 1380 | core::core_arch::aarch64::sve::generated | svst3_s16 | function | * [`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`). | |
| 1381 | core::core_arch::aarch64::sve::generated | svst3_s32 | function | * [`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`). | |
| 1382 | core::core_arch::aarch64::sve::generated | svst3_s64 | function | * [`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`). | |
| 1383 | core::core_arch::aarch64::sve::generated | svst3_s8 | function | * [`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`). | |
| 1384 | core::core_arch::aarch64::sve::generated | svst3_u16 | function | * [`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`). | |
| 1385 | core::core_arch::aarch64::sve::generated | svst3_u32 | function | * [`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`). | |
| 1386 | core::core_arch::aarch64::sve::generated | svst3_u64 | function | * [`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`). | |
| 1387 | core::core_arch::aarch64::sve::generated | svst3_u8 | function | * [`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`). | |
| 1388 | core::core_arch::aarch64::sve::generated | svst3_vnum_f32 | function | * [`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`). | |
| 1389 | core::core_arch::aarch64::sve::generated | svst3_vnum_f64 | function | * [`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`). | |
| 1390 | core::core_arch::aarch64::sve::generated | svst3_vnum_s16 | function | * [`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`). | |
| 1391 | core::core_arch::aarch64::sve::generated | svst3_vnum_s32 | function | * [`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`). | |
| 1392 | core::core_arch::aarch64::sve::generated | svst3_vnum_s64 | function | * [`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`). | |
| 1393 | core::core_arch::aarch64::sve::generated | svst3_vnum_s8 | function | * [`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`). | |
| 1394 | core::core_arch::aarch64::sve::generated | svst3_vnum_u16 | function | * [`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`). | |
| 1395 | core::core_arch::aarch64::sve::generated | svst3_vnum_u32 | function | * [`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`). | |
| 1396 | core::core_arch::aarch64::sve::generated | svst3_vnum_u64 | function | * [`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`). | |
| 1397 | core::core_arch::aarch64::sve::generated | svst3_vnum_u8 | function | * [`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`). | |
| 1398 | core::core_arch::aarch64::sve::generated | svst4_f32 | function | * [`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`). | |
| 1399 | core::core_arch::aarch64::sve::generated | svst4_f64 | function | * [`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`). | |
| 1400 | core::core_arch::aarch64::sve::generated | svst4_s16 | function | * [`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`). | |
| 1401 | core::core_arch::aarch64::sve::generated | svst4_s32 | function | * [`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`). | |
| 1402 | core::core_arch::aarch64::sve::generated | svst4_s64 | function | * [`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`). | |
| 1403 | core::core_arch::aarch64::sve::generated | svst4_s8 | function | * [`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`). | |
| 1404 | core::core_arch::aarch64::sve::generated | svst4_u16 | function | * [`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`). | |
| 1405 | core::core_arch::aarch64::sve::generated | svst4_u32 | function | * [`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`). | |
| 1406 | core::core_arch::aarch64::sve::generated | svst4_u64 | function | * [`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`). | |
| 1407 | core::core_arch::aarch64::sve::generated | svst4_u8 | function | * [`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`). | |
| 1408 | core::core_arch::aarch64::sve::generated | svst4_vnum_f32 | function | * [`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`). | |
| 1409 | core::core_arch::aarch64::sve::generated | svst4_vnum_f64 | function | * [`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`). | |
| 1410 | core::core_arch::aarch64::sve::generated | svst4_vnum_s16 | function | * [`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`). | |
| 1411 | core::core_arch::aarch64::sve::generated | svst4_vnum_s32 | function | * [`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`). | |
| 1412 | core::core_arch::aarch64::sve::generated | svst4_vnum_s64 | function | * [`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`). | |
| 1413 | core::core_arch::aarch64::sve::generated | svst4_vnum_s8 | function | * [`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`). | |
| 1414 | core::core_arch::aarch64::sve::generated | svst4_vnum_u16 | function | * [`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`). | |
| 1415 | core::core_arch::aarch64::sve::generated | svst4_vnum_u32 | function | * [`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`). | |
| 1416 | core::core_arch::aarch64::sve::generated | svst4_vnum_u64 | function | * [`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`). | |
| 1417 | core::core_arch::aarch64::sve::generated | svst4_vnum_u8 | function | * [`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`). | |
| 1418 | core::core_arch::aarch64::sve::generated | svstnt1_f32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1419 | core::core_arch::aarch64::sve::generated | svstnt1_f64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1420 | core::core_arch::aarch64::sve::generated | svstnt1_s16 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1421 | core::core_arch::aarch64::sve::generated | svstnt1_s32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1422 | core::core_arch::aarch64::sve::generated | svstnt1_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1423 | core::core_arch::aarch64::sve::generated | svstnt1_s8 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1424 | core::core_arch::aarch64::sve::generated | svstnt1_u16 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1425 | core::core_arch::aarch64::sve::generated | svstnt1_u32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1426 | core::core_arch::aarch64::sve::generated | svstnt1_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1427 | core::core_arch::aarch64::sve::generated | svstnt1_u8 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1428 | core::core_arch::aarch64::sve::generated | svstnt1_vnum_f32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1429 | core::core_arch::aarch64::sve::generated | svstnt1_vnum_f64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1430 | core::core_arch::aarch64::sve::generated | svstnt1_vnum_s16 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1431 | core::core_arch::aarch64::sve::generated | svstnt1_vnum_s32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1432 | core::core_arch::aarch64::sve::generated | svstnt1_vnum_s64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1433 | core::core_arch::aarch64::sve::generated | svstnt1_vnum_s8 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1434 | core::core_arch::aarch64::sve::generated | svstnt1_vnum_u16 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1435 | core::core_arch::aarch64::sve::generated | svstnt1_vnum_u32 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1436 | core::core_arch::aarch64::sve::generated | svstnt1_vnum_u64 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1437 | core::core_arch::aarch64::sve::generated | svstnt1_vnum_u8 | function | * [`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`). * Non-temporal accesses have special memory ordering rules, and [explicit barriers may be required for some applications](https://developer.arm.com/documentation/den0024/a/Memory-Ordering/Barriers/Non-temporal-load-and-store-pair?lang=en). | |
| 1438 | core::core_arch::aarch64::sve::generated | svundef2_f32 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1439 | core::core_arch::aarch64::sve::generated | svundef2_f64 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1440 | core::core_arch::aarch64::sve::generated | svundef2_s16 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1441 | core::core_arch::aarch64::sve::generated | svundef2_s32 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1442 | core::core_arch::aarch64::sve::generated | svundef2_s64 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1443 | core::core_arch::aarch64::sve::generated | svundef2_s8 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1444 | core::core_arch::aarch64::sve::generated | svundef2_u16 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1445 | core::core_arch::aarch64::sve::generated | svundef2_u32 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1446 | core::core_arch::aarch64::sve::generated | svundef2_u64 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1447 | core::core_arch::aarch64::sve::generated | svundef2_u8 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1448 | core::core_arch::aarch64::sve::generated | svundef3_f32 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1449 | core::core_arch::aarch64::sve::generated | svundef3_f64 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1450 | core::core_arch::aarch64::sve::generated | svundef3_s16 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1451 | core::core_arch::aarch64::sve::generated | svundef3_s32 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1452 | core::core_arch::aarch64::sve::generated | svundef3_s64 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1453 | core::core_arch::aarch64::sve::generated | svundef3_s8 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1454 | core::core_arch::aarch64::sve::generated | svundef3_u16 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1455 | core::core_arch::aarch64::sve::generated | svundef3_u32 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1456 | core::core_arch::aarch64::sve::generated | svundef3_u64 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1457 | core::core_arch::aarch64::sve::generated | svundef3_u8 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1458 | core::core_arch::aarch64::sve::generated | svundef4_f32 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1459 | core::core_arch::aarch64::sve::generated | svundef4_f64 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1460 | core::core_arch::aarch64::sve::generated | svundef4_s16 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1461 | core::core_arch::aarch64::sve::generated | svundef4_s32 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1462 | core::core_arch::aarch64::sve::generated | svundef4_s64 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1463 | core::core_arch::aarch64::sve::generated | svundef4_s8 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1464 | core::core_arch::aarch64::sve::generated | svundef4_u16 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1465 | core::core_arch::aarch64::sve::generated | svundef4_u32 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1466 | core::core_arch::aarch64::sve::generated | svundef4_u64 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1467 | core::core_arch::aarch64::sve::generated | svundef4_u8 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1468 | core::core_arch::aarch64::sve::generated | svundef_f32 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1469 | core::core_arch::aarch64::sve::generated | svundef_f64 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1470 | core::core_arch::aarch64::sve::generated | svundef_s16 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1471 | core::core_arch::aarch64::sve::generated | svundef_s32 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1472 | core::core_arch::aarch64::sve::generated | svundef_s64 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1473 | core::core_arch::aarch64::sve::generated | svundef_s8 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1474 | core::core_arch::aarch64::sve::generated | svundef_u16 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1475 | core::core_arch::aarch64::sve::generated | svundef_u32 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1476 | core::core_arch::aarch64::sve::generated | svundef_u64 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1477 | core::core_arch::aarch64::sve::generated | svundef_u8 | function | * This creates an uninitialized value, and may be unsound (like [`core::mem::uninitialized`]). | |
| 1478 | core::core_arch::amdgpu | ds_bpermute | function | ||
| 1479 | core::core_arch::amdgpu | ds_permute | function | ||
| 1480 | core::core_arch::amdgpu | perm | function | ||
| 1481 | core::core_arch::amdgpu | permlane16_swap | function | ||
| 1482 | core::core_arch::amdgpu | permlane16_u32 | function | ||
| 1483 | core::core_arch::amdgpu | permlane16_var | function | ||
| 1484 | core::core_arch::amdgpu | permlane32_swap | function | ||
| 1485 | core::core_arch::amdgpu | permlane64_u32 | function | ||
| 1486 | core::core_arch::amdgpu | permlanex16_u32 | function | ||
| 1487 | core::core_arch::amdgpu | permlanex16_var | function | ||
| 1488 | core::core_arch::amdgpu | readlane_u32 | function | ||
| 1489 | core::core_arch::amdgpu | readlane_u64 | function | ||
| 1490 | core::core_arch::amdgpu | s_barrier_signal | function | ||
| 1491 | core::core_arch::amdgpu | s_barrier_signal_isfirst | function | ||
| 1492 | core::core_arch::amdgpu | s_barrier_wait | function | ||
| 1493 | core::core_arch::amdgpu | s_get_barrier_state | function | ||
| 1494 | core::core_arch::amdgpu | sched_barrier | function | ||
| 1495 | core::core_arch::amdgpu | sched_group_barrier | function | ||
| 1496 | core::core_arch::amdgpu | update_dpp | function | ||
| 1497 | core::core_arch::amdgpu | writelane_u32 | function | ||
| 1498 | core::core_arch::amdgpu | writelane_u64 | function | ||
| 1499 | core::core_arch::arm::dsp | __qadd | function | ||
| 1500 | core::core_arch::arm::dsp | __qdbl | function | ||
| 1501 | core::core_arch::arm::dsp | __qsub | function | ||
| 1502 | core::core_arch::arm::dsp | __smlabb | function | ||
| 1503 | core::core_arch::arm::dsp | __smlabt | function | ||
| 1504 | core::core_arch::arm::dsp | __smlatb | function | ||
| 1505 | core::core_arch::arm::dsp | __smlatt | function | ||
| 1506 | core::core_arch::arm::dsp | __smlawb | function | ||
| 1507 | core::core_arch::arm::dsp | __smlawt | function | ||
| 1508 | core::core_arch::arm::dsp | __smulbb | function | ||
| 1509 | core::core_arch::arm::dsp | __smulbt | function | ||
| 1510 | core::core_arch::arm::dsp | __smultb | function | ||
| 1511 | core::core_arch::arm::dsp | __smultt | function | ||
| 1512 | core::core_arch::arm::dsp | __smulwb | function | ||
| 1513 | core::core_arch::arm::dsp | __smulwt | function | ||
| 1514 | core::core_arch::arm::sat | __ssat | function | ||
| 1515 | core::core_arch::arm::sat | __usat | function | ||
| 1516 | core::core_arch::arm::simd32 | __qadd16 | function | ||
| 1517 | core::core_arch::arm::simd32 | __qadd8 | function | ||
| 1518 | core::core_arch::arm::simd32 | __qasx | function | ||
| 1519 | core::core_arch::arm::simd32 | __qsax | function | ||
| 1520 | core::core_arch::arm::simd32 | __qsub16 | function | ||
| 1521 | core::core_arch::arm::simd32 | __qsub8 | function | ||
| 1522 | core::core_arch::arm::simd32 | __sadd16 | function | ||
| 1523 | core::core_arch::arm::simd32 | __sadd8 | function | ||
| 1524 | core::core_arch::arm::simd32 | __sasx | function | ||
| 1525 | core::core_arch::arm::simd32 | __sel | function | ||
| 1526 | core::core_arch::arm::simd32 | __shadd16 | function | ||
| 1527 | core::core_arch::arm::simd32 | __shadd8 | function | ||
| 1528 | core::core_arch::arm::simd32 | __shsub16 | function | ||
| 1529 | core::core_arch::arm::simd32 | __shsub8 | function | ||
| 1530 | core::core_arch::arm::simd32 | __smlad | function | ||
| 1531 | core::core_arch::arm::simd32 | __smlsd | function | ||
| 1532 | core::core_arch::arm::simd32 | __smuad | function | ||
| 1533 | core::core_arch::arm::simd32 | __smuadx | function | ||
| 1534 | core::core_arch::arm::simd32 | __smusd | function | ||
| 1535 | core::core_arch::arm::simd32 | __smusdx | function | ||
| 1536 | core::core_arch::arm::simd32 | __ssub8 | function | ||
| 1537 | core::core_arch::arm::simd32 | __usad8 | function | ||
| 1538 | core::core_arch::arm::simd32 | __usada8 | function | ||
| 1539 | core::core_arch::arm::simd32 | __usub8 | function | ||
| 1540 | core::core_arch::arm_shared::barrier | __dmb | function | ||
| 1541 | core::core_arch::arm_shared::barrier | __dsb | function | ||
| 1542 | core::core_arch::arm_shared::barrier | __isb | function | ||
| 1543 | core::core_arch::arm_shared::hints | __nop | function | ||
| 1544 | core::core_arch::arm_shared::hints | __sev | function | ||
| 1545 | core::core_arch::arm_shared::hints | __sevl | function | ||
| 1546 | core::core_arch::arm_shared::hints | __wfe | function | ||
| 1547 | core::core_arch::arm_shared::hints | __wfi | function | ||
| 1548 | core::core_arch::arm_shared::hints | __yield | function | ||
| 1549 | core::core_arch::arm_shared::neon::generated | vext_s64 | function | * Neon intrinsic unsafe | |
| 1550 | core::core_arch::arm_shared::neon::generated | vext_u64 | function | * Neon intrinsic unsafe | |
| 1551 | core::core_arch::arm_shared::neon::generated | vld1_dup_f16 | function | * Neon intrinsic unsafe | |
| 1552 | core::core_arch::arm_shared::neon::generated | vld1_dup_f32 | function | * Neon intrinsic unsafe | |
| 1553 | core::core_arch::arm_shared::neon::generated | vld1_dup_p16 | function | * Neon intrinsic unsafe | |
| 1554 | core::core_arch::arm_shared::neon::generated | vld1_dup_p64 | function | * Neon intrinsic unsafe | |
| 1555 | core::core_arch::arm_shared::neon::generated | vld1_dup_p8 | function | * Neon intrinsic unsafe | |
| 1556 | core::core_arch::arm_shared::neon::generated | vld1_dup_s16 | function | * Neon intrinsic unsafe | |
| 1557 | core::core_arch::arm_shared::neon::generated | vld1_dup_s32 | function | * Neon intrinsic unsafe | |
| 1558 | core::core_arch::arm_shared::neon::generated | vld1_dup_s64 | function | * Neon intrinsic unsafe | |
| 1559 | core::core_arch::arm_shared::neon::generated | vld1_dup_s8 | function | * Neon intrinsic unsafe | |
| 1560 | core::core_arch::arm_shared::neon::generated | vld1_dup_u16 | function | * Neon intrinsic unsafe | |
| 1561 | core::core_arch::arm_shared::neon::generated | vld1_dup_u32 | function | * Neon intrinsic unsafe | |
| 1562 | core::core_arch::arm_shared::neon::generated | vld1_dup_u64 | function | * Neon intrinsic unsafe | |
| 1563 | core::core_arch::arm_shared::neon::generated | vld1_dup_u8 | function | * Neon intrinsic unsafe | |
| 1564 | core::core_arch::arm_shared::neon::generated | vld1_f16_x2 | function | * Neon intrinsic unsafe | |
| 1565 | core::core_arch::arm_shared::neon::generated | vld1_f16_x3 | function | * Neon intrinsic unsafe | |
| 1566 | core::core_arch::arm_shared::neon::generated | vld1_f16_x4 | function | * Neon intrinsic unsafe | |
| 1567 | core::core_arch::arm_shared::neon::generated | vld1_f32_x2 | function | * Neon intrinsic unsafe | |
| 1568 | core::core_arch::arm_shared::neon::generated | vld1_f32_x3 | function | * Neon intrinsic unsafe | |
| 1569 | core::core_arch::arm_shared::neon::generated | vld1_f32_x4 | function | * Neon intrinsic unsafe | |
| 1570 | core::core_arch::arm_shared::neon::generated | vld1_lane_f16 | function | * Neon intrinsic unsafe | |
| 1571 | core::core_arch::arm_shared::neon::generated | vld1_lane_f32 | function | * Neon intrinsic unsafe | |
| 1572 | core::core_arch::arm_shared::neon::generated | vld1_lane_p16 | function | * Neon intrinsic unsafe | |
| 1573 | core::core_arch::arm_shared::neon::generated | vld1_lane_p64 | function | * Neon intrinsic unsafe | |
| 1574 | core::core_arch::arm_shared::neon::generated | vld1_lane_p8 | function | * Neon intrinsic unsafe | |
| 1575 | core::core_arch::arm_shared::neon::generated | vld1_lane_s16 | function | * Neon intrinsic unsafe | |
| 1576 | core::core_arch::arm_shared::neon::generated | vld1_lane_s32 | function | * Neon intrinsic unsafe | |
| 1577 | core::core_arch::arm_shared::neon::generated | vld1_lane_s64 | function | * Neon intrinsic unsafe | |
| 1578 | core::core_arch::arm_shared::neon::generated | vld1_lane_s8 | function | * Neon intrinsic unsafe | |
| 1579 | core::core_arch::arm_shared::neon::generated | vld1_lane_u16 | function | * Neon intrinsic unsafe | |
| 1580 | core::core_arch::arm_shared::neon::generated | vld1_lane_u32 | function | * Neon intrinsic unsafe | |
| 1581 | core::core_arch::arm_shared::neon::generated | vld1_lane_u64 | function | * Neon intrinsic unsafe | |
| 1582 | core::core_arch::arm_shared::neon::generated | vld1_lane_u8 | function | * Neon intrinsic unsafe | |
| 1583 | core::core_arch::arm_shared::neon::generated | vld1_p16_x2 | function | * Neon intrinsic unsafe | |
| 1584 | core::core_arch::arm_shared::neon::generated | vld1_p16_x3 | function | * Neon intrinsic unsafe | |
| 1585 | core::core_arch::arm_shared::neon::generated | vld1_p16_x4 | function | * Neon intrinsic unsafe | |
| 1586 | core::core_arch::arm_shared::neon::generated | vld1_p64_x2 | function | * Neon intrinsic unsafe | |
| 1587 | core::core_arch::arm_shared::neon::generated | vld1_p64_x3 | function | * Neon intrinsic unsafe | |
| 1588 | core::core_arch::arm_shared::neon::generated | vld1_p64_x4 | function | * Neon intrinsic unsafe | |
| 1589 | core::core_arch::arm_shared::neon::generated | vld1_p8_x2 | function | * Neon intrinsic unsafe | |
| 1590 | core::core_arch::arm_shared::neon::generated | vld1_p8_x3 | function | * Neon intrinsic unsafe | |
| 1591 | core::core_arch::arm_shared::neon::generated | vld1_p8_x4 | function | * Neon intrinsic unsafe | |
| 1592 | core::core_arch::arm_shared::neon::generated | vld1_s16_x2 | function | * Neon intrinsic unsafe | |
| 1593 | core::core_arch::arm_shared::neon::generated | vld1_s16_x3 | function | * Neon intrinsic unsafe | |
| 1594 | core::core_arch::arm_shared::neon::generated | vld1_s16_x4 | function | * Neon intrinsic unsafe | |
| 1595 | core::core_arch::arm_shared::neon::generated | vld1_s32_x2 | function | * Neon intrinsic unsafe | |
| 1596 | core::core_arch::arm_shared::neon::generated | vld1_s32_x3 | function | * Neon intrinsic unsafe | |
| 1597 | core::core_arch::arm_shared::neon::generated | vld1_s32_x4 | function | * Neon intrinsic unsafe | |
| 1598 | core::core_arch::arm_shared::neon::generated | vld1_s64_x2 | function | * Neon intrinsic unsafe | |
| 1599 | core::core_arch::arm_shared::neon::generated | vld1_s64_x3 | function | * Neon intrinsic unsafe | |
| 1600 | core::core_arch::arm_shared::neon::generated | vld1_s64_x4 | function | * Neon intrinsic unsafe | |
| 1601 | core::core_arch::arm_shared::neon::generated | vld1_s8_x2 | function | * Neon intrinsic unsafe | |
| 1602 | core::core_arch::arm_shared::neon::generated | vld1_s8_x3 | function | * Neon intrinsic unsafe | |
| 1603 | core::core_arch::arm_shared::neon::generated | vld1_s8_x4 | function | * Neon intrinsic unsafe | |
| 1604 | core::core_arch::arm_shared::neon::generated | vld1_u16_x2 | function | * Neon intrinsic unsafe | |
| 1605 | core::core_arch::arm_shared::neon::generated | vld1_u16_x3 | function | * Neon intrinsic unsafe | |
| 1606 | core::core_arch::arm_shared::neon::generated | vld1_u16_x4 | function | * Neon intrinsic unsafe | |
| 1607 | core::core_arch::arm_shared::neon::generated | vld1_u32_x2 | function | * Neon intrinsic unsafe | |
| 1608 | core::core_arch::arm_shared::neon::generated | vld1_u32_x3 | function | * Neon intrinsic unsafe | |
| 1609 | core::core_arch::arm_shared::neon::generated | vld1_u32_x4 | function | * Neon intrinsic unsafe | |
| 1610 | core::core_arch::arm_shared::neon::generated | vld1_u64_x2 | function | * Neon intrinsic unsafe | |
| 1611 | core::core_arch::arm_shared::neon::generated | vld1_u64_x3 | function | * Neon intrinsic unsafe | |
| 1612 | core::core_arch::arm_shared::neon::generated | vld1_u64_x4 | function | * Neon intrinsic unsafe | |
| 1613 | core::core_arch::arm_shared::neon::generated | vld1_u8_x2 | function | * Neon intrinsic unsafe | |
| 1614 | core::core_arch::arm_shared::neon::generated | vld1_u8_x3 | function | * Neon intrinsic unsafe | |
| 1615 | core::core_arch::arm_shared::neon::generated | vld1_u8_x4 | function | * Neon intrinsic unsafe | |
| 1616 | core::core_arch::arm_shared::neon::generated | vld1q_dup_f16 | function | * Neon intrinsic unsafe | |
| 1617 | core::core_arch::arm_shared::neon::generated | vld1q_dup_f32 | function | * Neon intrinsic unsafe | |
| 1618 | core::core_arch::arm_shared::neon::generated | vld1q_dup_p16 | function | * Neon intrinsic unsafe | |
| 1619 | core::core_arch::arm_shared::neon::generated | vld1q_dup_p64 | function | * Neon intrinsic unsafe | |
| 1620 | core::core_arch::arm_shared::neon::generated | vld1q_dup_p8 | function | * Neon intrinsic unsafe | |
| 1621 | core::core_arch::arm_shared::neon::generated | vld1q_dup_s16 | function | * Neon intrinsic unsafe | |
| 1622 | core::core_arch::arm_shared::neon::generated | vld1q_dup_s32 | function | * Neon intrinsic unsafe | |
| 1623 | core::core_arch::arm_shared::neon::generated | vld1q_dup_s64 | function | * Neon intrinsic unsafe | |
| 1624 | core::core_arch::arm_shared::neon::generated | vld1q_dup_s8 | function | * Neon intrinsic unsafe | |
| 1625 | core::core_arch::arm_shared::neon::generated | vld1q_dup_u16 | function | * Neon intrinsic unsafe | |
| 1626 | core::core_arch::arm_shared::neon::generated | vld1q_dup_u32 | function | * Neon intrinsic unsafe | |
| 1627 | core::core_arch::arm_shared::neon::generated | vld1q_dup_u64 | function | * Neon intrinsic unsafe | |
| 1628 | core::core_arch::arm_shared::neon::generated | vld1q_dup_u8 | function | * Neon intrinsic unsafe | |
| 1629 | core::core_arch::arm_shared::neon::generated | vld1q_f16_x2 | function | * Neon intrinsic unsafe | |
| 1630 | core::core_arch::arm_shared::neon::generated | vld1q_f16_x3 | function | * Neon intrinsic unsafe | |
| 1631 | core::core_arch::arm_shared::neon::generated | vld1q_f16_x4 | function | * Neon intrinsic unsafe | |
| 1632 | core::core_arch::arm_shared::neon::generated | vld1q_f32_x2 | function | * Neon intrinsic unsafe | |
| 1633 | core::core_arch::arm_shared::neon::generated | vld1q_f32_x3 | function | * Neon intrinsic unsafe | |
| 1634 | core::core_arch::arm_shared::neon::generated | vld1q_f32_x4 | function | * Neon intrinsic unsafe | |
| 1635 | core::core_arch::arm_shared::neon::generated | vld1q_lane_f16 | function | * Neon intrinsic unsafe | |
| 1636 | core::core_arch::arm_shared::neon::generated | vld1q_lane_f32 | function | * Neon intrinsic unsafe | |
| 1637 | core::core_arch::arm_shared::neon::generated | vld1q_lane_p16 | function | * Neon intrinsic unsafe | |
| 1638 | core::core_arch::arm_shared::neon::generated | vld1q_lane_p64 | function | * Neon intrinsic unsafe | |
| 1639 | core::core_arch::arm_shared::neon::generated | vld1q_lane_p8 | function | * Neon intrinsic unsafe | |
| 1640 | core::core_arch::arm_shared::neon::generated | vld1q_lane_s16 | function | * Neon intrinsic unsafe | |
| 1641 | core::core_arch::arm_shared::neon::generated | vld1q_lane_s32 | function | * Neon intrinsic unsafe | |
| 1642 | core::core_arch::arm_shared::neon::generated | vld1q_lane_s64 | function | * Neon intrinsic unsafe | |
| 1643 | core::core_arch::arm_shared::neon::generated | vld1q_lane_s8 | function | * Neon intrinsic unsafe | |
| 1644 | core::core_arch::arm_shared::neon::generated | vld1q_lane_u16 | function | * Neon intrinsic unsafe | |
| 1645 | core::core_arch::arm_shared::neon::generated | vld1q_lane_u32 | function | * Neon intrinsic unsafe | |
| 1646 | core::core_arch::arm_shared::neon::generated | vld1q_lane_u64 | function | * Neon intrinsic unsafe | |
| 1647 | core::core_arch::arm_shared::neon::generated | vld1q_lane_u8 | function | * Neon intrinsic unsafe | |
| 1648 | core::core_arch::arm_shared::neon::generated | vld1q_p16_x2 | function | * Neon intrinsic unsafe | |
| 1649 | core::core_arch::arm_shared::neon::generated | vld1q_p16_x3 | function | * Neon intrinsic unsafe | |
| 1650 | core::core_arch::arm_shared::neon::generated | vld1q_p16_x4 | function | * Neon intrinsic unsafe | |
| 1651 | core::core_arch::arm_shared::neon::generated | vld1q_p64_x2 | function | * Neon intrinsic unsafe | |
| 1652 | core::core_arch::arm_shared::neon::generated | vld1q_p64_x3 | function | * Neon intrinsic unsafe | |
| 1653 | core::core_arch::arm_shared::neon::generated | vld1q_p64_x4 | function | * Neon intrinsic unsafe | |
| 1654 | core::core_arch::arm_shared::neon::generated | vld1q_p8_x2 | function | * Neon intrinsic unsafe | |
| 1655 | core::core_arch::arm_shared::neon::generated | vld1q_p8_x3 | function | * Neon intrinsic unsafe | |
| 1656 | core::core_arch::arm_shared::neon::generated | vld1q_p8_x4 | function | * Neon intrinsic unsafe | |
| 1657 | core::core_arch::arm_shared::neon::generated | vld1q_s16_x2 | function | * Neon intrinsic unsafe | |
| 1658 | core::core_arch::arm_shared::neon::generated | vld1q_s16_x3 | function | * Neon intrinsic unsafe | |
| 1659 | core::core_arch::arm_shared::neon::generated | vld1q_s16_x4 | function | * Neon intrinsic unsafe | |
| 1660 | core::core_arch::arm_shared::neon::generated | vld1q_s32_x2 | function | * Neon intrinsic unsafe | |
| 1661 | core::core_arch::arm_shared::neon::generated | vld1q_s32_x3 | function | * Neon intrinsic unsafe | |
| 1662 | core::core_arch::arm_shared::neon::generated | vld1q_s32_x4 | function | * Neon intrinsic unsafe | |
| 1663 | core::core_arch::arm_shared::neon::generated | vld1q_s64_x2 | function | * Neon intrinsic unsafe | |
| 1664 | core::core_arch::arm_shared::neon::generated | vld1q_s64_x3 | function | * Neon intrinsic unsafe | |
| 1665 | core::core_arch::arm_shared::neon::generated | vld1q_s64_x4 | function | * Neon intrinsic unsafe | |
| 1666 | core::core_arch::arm_shared::neon::generated | vld1q_s8_x2 | function | * Neon intrinsic unsafe | |
| 1667 | core::core_arch::arm_shared::neon::generated | vld1q_s8_x3 | function | * Neon intrinsic unsafe | |
| 1668 | core::core_arch::arm_shared::neon::generated | vld1q_s8_x4 | function | * Neon intrinsic unsafe | |
| 1669 | core::core_arch::arm_shared::neon::generated | vld1q_u16_x2 | function | * Neon intrinsic unsafe | |
| 1670 | core::core_arch::arm_shared::neon::generated | vld1q_u16_x3 | function | * Neon intrinsic unsafe | |
| 1671 | core::core_arch::arm_shared::neon::generated | vld1q_u16_x4 | function | * Neon intrinsic unsafe | |
| 1672 | core::core_arch::arm_shared::neon::generated | vld1q_u32_x2 | function | * Neon intrinsic unsafe | |
| 1673 | core::core_arch::arm_shared::neon::generated | vld1q_u32_x3 | function | * Neon intrinsic unsafe | |
| 1674 | core::core_arch::arm_shared::neon::generated | vld1q_u32_x4 | function | * Neon intrinsic unsafe | |
| 1675 | core::core_arch::arm_shared::neon::generated | vld1q_u64_x2 | function | * Neon intrinsic unsafe | |
| 1676 | core::core_arch::arm_shared::neon::generated | vld1q_u64_x3 | function | * Neon intrinsic unsafe | |
| 1677 | core::core_arch::arm_shared::neon::generated | vld1q_u64_x4 | function | * Neon intrinsic unsafe | |
| 1678 | core::core_arch::arm_shared::neon::generated | vld1q_u8_x2 | function | * Neon intrinsic unsafe | |
| 1679 | core::core_arch::arm_shared::neon::generated | vld1q_u8_x3 | function | * Neon intrinsic unsafe | |
| 1680 | core::core_arch::arm_shared::neon::generated | vld1q_u8_x4 | function | * Neon intrinsic unsafe | |
| 1681 | core::core_arch::arm_shared::neon::generated | vld2_dup_f16 | function | * Neon intrinsic unsafe | |
| 1682 | core::core_arch::arm_shared::neon::generated | vld2_dup_f32 | function | * Neon intrinsic unsafe | |
| 1683 | core::core_arch::arm_shared::neon::generated | vld2_dup_p16 | function | * Neon intrinsic unsafe | |
| 1684 | core::core_arch::arm_shared::neon::generated | vld2_dup_p64 | function | * Neon intrinsic unsafe | |
| 1685 | core::core_arch::arm_shared::neon::generated | vld2_dup_p8 | function | * Neon intrinsic unsafe | |
| 1686 | core::core_arch::arm_shared::neon::generated | vld2_dup_s16 | function | * Neon intrinsic unsafe | |
| 1687 | core::core_arch::arm_shared::neon::generated | vld2_dup_s32 | function | * Neon intrinsic unsafe | |
| 1688 | core::core_arch::arm_shared::neon::generated | vld2_dup_s64 | function | * Neon intrinsic unsafe | |
| 1689 | core::core_arch::arm_shared::neon::generated | vld2_dup_s8 | function | * Neon intrinsic unsafe | |
| 1690 | core::core_arch::arm_shared::neon::generated | vld2_dup_u16 | function | * Neon intrinsic unsafe | |
| 1691 | core::core_arch::arm_shared::neon::generated | vld2_dup_u32 | function | * Neon intrinsic unsafe | |
| 1692 | core::core_arch::arm_shared::neon::generated | vld2_dup_u64 | function | * Neon intrinsic unsafe | |
| 1693 | core::core_arch::arm_shared::neon::generated | vld2_dup_u8 | function | * Neon intrinsic unsafe | |
| 1694 | core::core_arch::arm_shared::neon::generated | vld2_f16 | function | * Neon intrinsic unsafe | |
| 1695 | core::core_arch::arm_shared::neon::generated | vld2_f32 | function | * Neon intrinsic unsafe | |
| 1696 | core::core_arch::arm_shared::neon::generated | vld2_lane_f16 | function | * Neon intrinsic unsafe | |
| 1697 | core::core_arch::arm_shared::neon::generated | vld2_lane_f32 | function | * Neon intrinsic unsafe | |
| 1698 | core::core_arch::arm_shared::neon::generated | vld2_lane_p16 | function | * Neon intrinsic unsafe | |
| 1699 | core::core_arch::arm_shared::neon::generated | vld2_lane_p8 | function | * Neon intrinsic unsafe | |
| 1700 | core::core_arch::arm_shared::neon::generated | vld2_lane_s16 | function | * Neon intrinsic unsafe | |
| 1701 | core::core_arch::arm_shared::neon::generated | vld2_lane_s32 | function | * Neon intrinsic unsafe | |
| 1702 | core::core_arch::arm_shared::neon::generated | vld2_lane_s8 | function | * Neon intrinsic unsafe | |
| 1703 | core::core_arch::arm_shared::neon::generated | vld2_lane_u16 | function | * Neon intrinsic unsafe | |
| 1704 | core::core_arch::arm_shared::neon::generated | vld2_lane_u32 | function | * Neon intrinsic unsafe | |
| 1705 | core::core_arch::arm_shared::neon::generated | vld2_lane_u8 | function | * Neon intrinsic unsafe | |
| 1706 | core::core_arch::arm_shared::neon::generated | vld2_p16 | function | * Neon intrinsic unsafe | |
| 1707 | core::core_arch::arm_shared::neon::generated | vld2_p64 | function | * Neon intrinsic unsafe | |
| 1708 | core::core_arch::arm_shared::neon::generated | vld2_p8 | function | * Neon intrinsic unsafe | |
| 1709 | core::core_arch::arm_shared::neon::generated | vld2_s16 | function | * Neon intrinsic unsafe | |
| 1710 | core::core_arch::arm_shared::neon::generated | vld2_s32 | function | * Neon intrinsic unsafe | |
| 1711 | core::core_arch::arm_shared::neon::generated | vld2_s64 | function | * Neon intrinsic unsafe | |
| 1712 | core::core_arch::arm_shared::neon::generated | vld2_s8 | function | * Neon intrinsic unsafe | |
| 1713 | core::core_arch::arm_shared::neon::generated | vld2_u16 | function | * Neon intrinsic unsafe | |
| 1714 | core::core_arch::arm_shared::neon::generated | vld2_u32 | function | * Neon intrinsic unsafe | |
| 1715 | core::core_arch::arm_shared::neon::generated | vld2_u64 | function | * Neon intrinsic unsafe | |
| 1716 | core::core_arch::arm_shared::neon::generated | vld2_u8 | function | * Neon intrinsic unsafe | |
| 1717 | core::core_arch::arm_shared::neon::generated | vld2q_dup_f16 | function | * Neon intrinsic unsafe | |
| 1718 | core::core_arch::arm_shared::neon::generated | vld2q_dup_f32 | function | * Neon intrinsic unsafe | |
| 1719 | core::core_arch::arm_shared::neon::generated | vld2q_dup_p16 | function | * Neon intrinsic unsafe | |
| 1720 | core::core_arch::arm_shared::neon::generated | vld2q_dup_p8 | function | * Neon intrinsic unsafe | |
| 1721 | core::core_arch::arm_shared::neon::generated | vld2q_dup_s16 | function | * Neon intrinsic unsafe | |
| 1722 | core::core_arch::arm_shared::neon::generated | vld2q_dup_s32 | function | * Neon intrinsic unsafe | |
| 1723 | core::core_arch::arm_shared::neon::generated | vld2q_dup_s8 | function | * Neon intrinsic unsafe | |
| 1724 | core::core_arch::arm_shared::neon::generated | vld2q_dup_u16 | function | * Neon intrinsic unsafe | |
| 1725 | core::core_arch::arm_shared::neon::generated | vld2q_dup_u32 | function | * Neon intrinsic unsafe | |
| 1726 | core::core_arch::arm_shared::neon::generated | vld2q_dup_u8 | function | * Neon intrinsic unsafe | |
| 1727 | core::core_arch::arm_shared::neon::generated | vld2q_f16 | function | * Neon intrinsic unsafe | |
| 1728 | core::core_arch::arm_shared::neon::generated | vld2q_f32 | function | * Neon intrinsic unsafe | |
| 1729 | core::core_arch::arm_shared::neon::generated | vld2q_lane_f16 | function | * Neon intrinsic unsafe | |
| 1730 | core::core_arch::arm_shared::neon::generated | vld2q_lane_f32 | function | * Neon intrinsic unsafe | |
| 1731 | core::core_arch::arm_shared::neon::generated | vld2q_lane_p16 | function | * Neon intrinsic unsafe | |
| 1732 | core::core_arch::arm_shared::neon::generated | vld2q_lane_s16 | function | * Neon intrinsic unsafe | |
| 1733 | core::core_arch::arm_shared::neon::generated | vld2q_lane_s32 | function | * Neon intrinsic unsafe | |
| 1734 | core::core_arch::arm_shared::neon::generated | vld2q_lane_u16 | function | * Neon intrinsic unsafe | |
| 1735 | core::core_arch::arm_shared::neon::generated | vld2q_lane_u32 | function | * Neon intrinsic unsafe | |
| 1736 | core::core_arch::arm_shared::neon::generated | vld2q_p16 | function | * Neon intrinsic unsafe | |
| 1737 | core::core_arch::arm_shared::neon::generated | vld2q_p8 | function | * Neon intrinsic unsafe | |
| 1738 | core::core_arch::arm_shared::neon::generated | vld2q_s16 | function | * Neon intrinsic unsafe | |
| 1739 | core::core_arch::arm_shared::neon::generated | vld2q_s32 | function | * Neon intrinsic unsafe | |
| 1740 | core::core_arch::arm_shared::neon::generated | vld2q_s8 | function | * Neon intrinsic unsafe | |
| 1741 | core::core_arch::arm_shared::neon::generated | vld2q_u16 | function | * Neon intrinsic unsafe | |
| 1742 | core::core_arch::arm_shared::neon::generated | vld2q_u32 | function | * Neon intrinsic unsafe | |
| 1743 | core::core_arch::arm_shared::neon::generated | vld2q_u8 | function | * Neon intrinsic unsafe | |
| 1744 | core::core_arch::arm_shared::neon::generated | vld3_dup_f16 | function | * Neon intrinsic unsafe | |
| 1745 | core::core_arch::arm_shared::neon::generated | vld3_dup_f32 | function | * Neon intrinsic unsafe | |
| 1746 | core::core_arch::arm_shared::neon::generated | vld3_dup_p16 | function | * Neon intrinsic unsafe | |
| 1747 | core::core_arch::arm_shared::neon::generated | vld3_dup_p64 | function | * Neon intrinsic unsafe | |
| 1748 | core::core_arch::arm_shared::neon::generated | vld3_dup_p8 | function | * Neon intrinsic unsafe | |
| 1749 | core::core_arch::arm_shared::neon::generated | vld3_dup_s16 | function | * Neon intrinsic unsafe | |
| 1750 | core::core_arch::arm_shared::neon::generated | vld3_dup_s32 | function | * Neon intrinsic unsafe | |
| 1751 | core::core_arch::arm_shared::neon::generated | vld3_dup_s64 | function | * Neon intrinsic unsafe | |
| 1752 | core::core_arch::arm_shared::neon::generated | vld3_dup_s8 | function | * Neon intrinsic unsafe | |
| 1753 | core::core_arch::arm_shared::neon::generated | vld3_dup_u16 | function | * Neon intrinsic unsafe | |
| 1754 | core::core_arch::arm_shared::neon::generated | vld3_dup_u32 | function | * Neon intrinsic unsafe | |
| 1755 | core::core_arch::arm_shared::neon::generated | vld3_dup_u64 | function | * Neon intrinsic unsafe | |
| 1756 | core::core_arch::arm_shared::neon::generated | vld3_dup_u8 | function | * Neon intrinsic unsafe | |
| 1757 | core::core_arch::arm_shared::neon::generated | vld3_f16 | function | * Neon intrinsic unsafe | |
| 1758 | core::core_arch::arm_shared::neon::generated | vld3_f32 | function | * Neon intrinsic unsafe | |
| 1759 | core::core_arch::arm_shared::neon::generated | vld3_lane_f16 | function | * Neon intrinsic unsafe | |
| 1760 | core::core_arch::arm_shared::neon::generated | vld3_lane_f32 | function | * Neon intrinsic unsafe | |
| 1761 | core::core_arch::arm_shared::neon::generated | vld3_lane_p16 | function | * Neon intrinsic unsafe | |
| 1762 | core::core_arch::arm_shared::neon::generated | vld3_lane_p8 | function | * Neon intrinsic unsafe | |
| 1763 | core::core_arch::arm_shared::neon::generated | vld3_lane_s16 | function | * Neon intrinsic unsafe | |
| 1764 | core::core_arch::arm_shared::neon::generated | vld3_lane_s32 | function | * Neon intrinsic unsafe | |
| 1765 | core::core_arch::arm_shared::neon::generated | vld3_lane_s8 | function | * Neon intrinsic unsafe | |
| 1766 | core::core_arch::arm_shared::neon::generated | vld3_lane_u16 | function | * Neon intrinsic unsafe | |
| 1767 | core::core_arch::arm_shared::neon::generated | vld3_lane_u32 | function | * Neon intrinsic unsafe | |
| 1768 | core::core_arch::arm_shared::neon::generated | vld3_lane_u8 | function | * Neon intrinsic unsafe | |
| 1769 | core::core_arch::arm_shared::neon::generated | vld3_p16 | function | * Neon intrinsic unsafe | |
| 1770 | core::core_arch::arm_shared::neon::generated | vld3_p64 | function | * Neon intrinsic unsafe | |
| 1771 | core::core_arch::arm_shared::neon::generated | vld3_p8 | function | * Neon intrinsic unsafe | |
| 1772 | core::core_arch::arm_shared::neon::generated | vld3_s16 | function | * Neon intrinsic unsafe | |
| 1773 | core::core_arch::arm_shared::neon::generated | vld3_s32 | function | * Neon intrinsic unsafe | |
| 1774 | core::core_arch::arm_shared::neon::generated | vld3_s64 | function | * Neon intrinsic unsafe | |
| 1775 | core::core_arch::arm_shared::neon::generated | vld3_s8 | function | * Neon intrinsic unsafe | |
| 1776 | core::core_arch::arm_shared::neon::generated | vld3_u16 | function | * Neon intrinsic unsafe | |
| 1777 | core::core_arch::arm_shared::neon::generated | vld3_u32 | function | * Neon intrinsic unsafe | |
| 1778 | core::core_arch::arm_shared::neon::generated | vld3_u64 | function | * Neon intrinsic unsafe | |
| 1779 | core::core_arch::arm_shared::neon::generated | vld3_u8 | function | * Neon intrinsic unsafe | |
| 1780 | core::core_arch::arm_shared::neon::generated | vld3q_dup_f16 | function | * Neon intrinsic unsafe | |
| 1781 | core::core_arch::arm_shared::neon::generated | vld3q_dup_f32 | function | * Neon intrinsic unsafe | |
| 1782 | core::core_arch::arm_shared::neon::generated | vld3q_dup_p16 | function | * Neon intrinsic unsafe | |
| 1783 | core::core_arch::arm_shared::neon::generated | vld3q_dup_p8 | function | * Neon intrinsic unsafe | |
| 1784 | core::core_arch::arm_shared::neon::generated | vld3q_dup_s16 | function | * Neon intrinsic unsafe | |
| 1785 | core::core_arch::arm_shared::neon::generated | vld3q_dup_s32 | function | * Neon intrinsic unsafe | |
| 1786 | core::core_arch::arm_shared::neon::generated | vld3q_dup_s8 | function | * Neon intrinsic unsafe | |
| 1787 | core::core_arch::arm_shared::neon::generated | vld3q_dup_u16 | function | * Neon intrinsic unsafe | |
| 1788 | core::core_arch::arm_shared::neon::generated | vld3q_dup_u32 | function | * Neon intrinsic unsafe | |
| 1789 | core::core_arch::arm_shared::neon::generated | vld3q_dup_u8 | function | * Neon intrinsic unsafe | |
| 1790 | core::core_arch::arm_shared::neon::generated | vld3q_f16 | function | * Neon intrinsic unsafe | |
| 1791 | core::core_arch::arm_shared::neon::generated | vld3q_f32 | function | * Neon intrinsic unsafe | |
| 1792 | core::core_arch::arm_shared::neon::generated | vld3q_lane_f16 | function | * Neon intrinsic unsafe | |
| 1793 | core::core_arch::arm_shared::neon::generated | vld3q_lane_f32 | function | * Neon intrinsic unsafe | |
| 1794 | core::core_arch::arm_shared::neon::generated | vld3q_lane_p16 | function | * Neon intrinsic unsafe | |
| 1795 | core::core_arch::arm_shared::neon::generated | vld3q_lane_s16 | function | * Neon intrinsic unsafe | |
| 1796 | core::core_arch::arm_shared::neon::generated | vld3q_lane_s32 | function | * Neon intrinsic unsafe | |
| 1797 | core::core_arch::arm_shared::neon::generated | vld3q_lane_u16 | function | * Neon intrinsic unsafe | |
| 1798 | core::core_arch::arm_shared::neon::generated | vld3q_lane_u32 | function | * Neon intrinsic unsafe | |
| 1799 | core::core_arch::arm_shared::neon::generated | vld3q_p16 | function | * Neon intrinsic unsafe | |
| 1800 | core::core_arch::arm_shared::neon::generated | vld3q_p8 | function | * Neon intrinsic unsafe | |
| 1801 | core::core_arch::arm_shared::neon::generated | vld3q_s16 | function | * Neon intrinsic unsafe | |
| 1802 | core::core_arch::arm_shared::neon::generated | vld3q_s32 | function | * Neon intrinsic unsafe | |
| 1803 | core::core_arch::arm_shared::neon::generated | vld3q_s8 | function | * Neon intrinsic unsafe | |
| 1804 | core::core_arch::arm_shared::neon::generated | vld3q_u16 | function | * Neon intrinsic unsafe | |
| 1805 | core::core_arch::arm_shared::neon::generated | vld3q_u32 | function | * Neon intrinsic unsafe | |
| 1806 | core::core_arch::arm_shared::neon::generated | vld3q_u8 | function | * Neon intrinsic unsafe | |
| 1807 | core::core_arch::arm_shared::neon::generated | vld4_dup_f16 | function | * Neon intrinsic unsafe | |
| 1808 | core::core_arch::arm_shared::neon::generated | vld4_dup_f32 | function | * Neon intrinsic unsafe | |
| 1809 | core::core_arch::arm_shared::neon::generated | vld4_dup_p16 | function | * Neon intrinsic unsafe | |
| 1810 | core::core_arch::arm_shared::neon::generated | vld4_dup_p64 | function | * Neon intrinsic unsafe | |
| 1811 | core::core_arch::arm_shared::neon::generated | vld4_dup_p8 | function | * Neon intrinsic unsafe | |
| 1812 | core::core_arch::arm_shared::neon::generated | vld4_dup_s16 | function | * Neon intrinsic unsafe | |
| 1813 | core::core_arch::arm_shared::neon::generated | vld4_dup_s32 | function | * Neon intrinsic unsafe | |
| 1814 | core::core_arch::arm_shared::neon::generated | vld4_dup_s64 | function | * Neon intrinsic unsafe | |
| 1815 | core::core_arch::arm_shared::neon::generated | vld4_dup_s8 | function | * Neon intrinsic unsafe | |
| 1816 | core::core_arch::arm_shared::neon::generated | vld4_dup_u16 | function | * Neon intrinsic unsafe | |
| 1817 | core::core_arch::arm_shared::neon::generated | vld4_dup_u32 | function | * Neon intrinsic unsafe | |
| 1818 | core::core_arch::arm_shared::neon::generated | vld4_dup_u64 | function | * Neon intrinsic unsafe | |
| 1819 | core::core_arch::arm_shared::neon::generated | vld4_dup_u8 | function | * Neon intrinsic unsafe | |
| 1820 | core::core_arch::arm_shared::neon::generated | vld4_f16 | function | * Neon intrinsic unsafe | |
| 1821 | core::core_arch::arm_shared::neon::generated | vld4_f32 | function | * Neon intrinsic unsafe | |
| 1822 | core::core_arch::arm_shared::neon::generated | vld4_lane_f16 | function | * Neon intrinsic unsafe | |
| 1823 | core::core_arch::arm_shared::neon::generated | vld4_lane_f32 | function | * Neon intrinsic unsafe | |
| 1824 | core::core_arch::arm_shared::neon::generated | vld4_lane_p16 | function | * Neon intrinsic unsafe | |
| 1825 | core::core_arch::arm_shared::neon::generated | vld4_lane_p8 | function | * Neon intrinsic unsafe | |
| 1826 | core::core_arch::arm_shared::neon::generated | vld4_lane_s16 | function | * Neon intrinsic unsafe | |
| 1827 | core::core_arch::arm_shared::neon::generated | vld4_lane_s32 | function | * Neon intrinsic unsafe | |
| 1828 | core::core_arch::arm_shared::neon::generated | vld4_lane_s8 | function | * Neon intrinsic unsafe | |
| 1829 | core::core_arch::arm_shared::neon::generated | vld4_lane_u16 | function | * Neon intrinsic unsafe | |
| 1830 | core::core_arch::arm_shared::neon::generated | vld4_lane_u32 | function | * Neon intrinsic unsafe | |
| 1831 | core::core_arch::arm_shared::neon::generated | vld4_lane_u8 | function | * Neon intrinsic unsafe | |
| 1832 | core::core_arch::arm_shared::neon::generated | vld4_p16 | function | * Neon intrinsic unsafe | |
| 1833 | core::core_arch::arm_shared::neon::generated | vld4_p64 | function | * Neon intrinsic unsafe | |
| 1834 | core::core_arch::arm_shared::neon::generated | vld4_p8 | function | * Neon intrinsic unsafe | |
| 1835 | core::core_arch::arm_shared::neon::generated | vld4_s16 | function | * Neon intrinsic unsafe | |
| 1836 | core::core_arch::arm_shared::neon::generated | vld4_s32 | function | * Neon intrinsic unsafe | |
| 1837 | core::core_arch::arm_shared::neon::generated | vld4_s64 | function | * Neon intrinsic unsafe | |
| 1838 | core::core_arch::arm_shared::neon::generated | vld4_s8 | function | * Neon intrinsic unsafe | |
| 1839 | core::core_arch::arm_shared::neon::generated | vld4_u16 | function | * Neon intrinsic unsafe | |
| 1840 | core::core_arch::arm_shared::neon::generated | vld4_u32 | function | * Neon intrinsic unsafe | |
| 1841 | core::core_arch::arm_shared::neon::generated | vld4_u64 | function | * Neon intrinsic unsafe | |
| 1842 | core::core_arch::arm_shared::neon::generated | vld4_u8 | function | * Neon intrinsic unsafe | |
| 1843 | core::core_arch::arm_shared::neon::generated | vld4q_dup_f16 | function | * Neon intrinsic unsafe | |
| 1844 | core::core_arch::arm_shared::neon::generated | vld4q_dup_f32 | function | * Neon intrinsic unsafe | |
| 1845 | core::core_arch::arm_shared::neon::generated | vld4q_dup_p16 | function | * Neon intrinsic unsafe | |
| 1846 | core::core_arch::arm_shared::neon::generated | vld4q_dup_p8 | function | * Neon intrinsic unsafe | |
| 1847 | core::core_arch::arm_shared::neon::generated | vld4q_dup_s16 | function | * Neon intrinsic unsafe | |
| 1848 | core::core_arch::arm_shared::neon::generated | vld4q_dup_s32 | function | * Neon intrinsic unsafe | |
| 1849 | core::core_arch::arm_shared::neon::generated | vld4q_dup_s8 | function | * Neon intrinsic unsafe | |
| 1850 | core::core_arch::arm_shared::neon::generated | vld4q_dup_u16 | function | * Neon intrinsic unsafe | |
| 1851 | core::core_arch::arm_shared::neon::generated | vld4q_dup_u32 | function | * Neon intrinsic unsafe | |
| 1852 | core::core_arch::arm_shared::neon::generated | vld4q_dup_u8 | function | * Neon intrinsic unsafe | |
| 1853 | core::core_arch::arm_shared::neon::generated | vld4q_f16 | function | * Neon intrinsic unsafe | |
| 1854 | core::core_arch::arm_shared::neon::generated | vld4q_f32 | function | * Neon intrinsic unsafe | |
| 1855 | core::core_arch::arm_shared::neon::generated | vld4q_lane_f16 | function | * Neon intrinsic unsafe | |
| 1856 | core::core_arch::arm_shared::neon::generated | vld4q_lane_f32 | function | * Neon intrinsic unsafe | |
| 1857 | core::core_arch::arm_shared::neon::generated | vld4q_lane_p16 | function | * Neon intrinsic unsafe | |
| 1858 | core::core_arch::arm_shared::neon::generated | vld4q_lane_s16 | function | * Neon intrinsic unsafe | |
| 1859 | core::core_arch::arm_shared::neon::generated | vld4q_lane_s32 | function | * Neon intrinsic unsafe | |
| 1860 | core::core_arch::arm_shared::neon::generated | vld4q_lane_u16 | function | * Neon intrinsic unsafe | |
| 1861 | core::core_arch::arm_shared::neon::generated | vld4q_lane_u32 | function | * Neon intrinsic unsafe | |
| 1862 | core::core_arch::arm_shared::neon::generated | vld4q_p16 | function | * Neon intrinsic unsafe | |
| 1863 | core::core_arch::arm_shared::neon::generated | vld4q_p8 | function | * Neon intrinsic unsafe | |
| 1864 | core::core_arch::arm_shared::neon::generated | vld4q_s16 | function | * Neon intrinsic unsafe | |
| 1865 | core::core_arch::arm_shared::neon::generated | vld4q_s32 | function | * Neon intrinsic unsafe | |
| 1866 | core::core_arch::arm_shared::neon::generated | vld4q_s8 | function | * Neon intrinsic unsafe | |
| 1867 | core::core_arch::arm_shared::neon::generated | vld4q_u16 | function | * Neon intrinsic unsafe | |
| 1868 | core::core_arch::arm_shared::neon::generated | vld4q_u32 | function | * Neon intrinsic unsafe | |
| 1869 | core::core_arch::arm_shared::neon::generated | vld4q_u8 | function | * Neon intrinsic unsafe | |
| 1870 | core::core_arch::arm_shared::neon::generated | vldrq_p128 | function | * Neon intrinsic unsafe | |
| 1871 | core::core_arch::arm_shared::neon::generated | vst1_f16_x2 | function | * Neon intrinsic unsafe | |
| 1872 | core::core_arch::arm_shared::neon::generated | vst1_f16_x3 | function | * Neon intrinsic unsafe | |
| 1873 | core::core_arch::arm_shared::neon::generated | vst1_f16_x4 | function | * Neon intrinsic unsafe | |
| 1874 | core::core_arch::arm_shared::neon::generated | vst1_f32_x2 | function | * Neon intrinsic unsafe | |
| 1875 | core::core_arch::arm_shared::neon::generated | vst1_f32_x3 | function | * Neon intrinsic unsafe | |
| 1876 | core::core_arch::arm_shared::neon::generated | vst1_f32_x4 | function | * Neon intrinsic unsafe | |
| 1877 | core::core_arch::arm_shared::neon::generated | vst1_lane_f16 | function | * Neon intrinsic unsafe | |
| 1878 | core::core_arch::arm_shared::neon::generated | vst1_lane_f32 | function | * Neon intrinsic unsafe | |
| 1879 | core::core_arch::arm_shared::neon::generated | vst1_lane_p16 | function | * Neon intrinsic unsafe | |
| 1880 | core::core_arch::arm_shared::neon::generated | vst1_lane_p64 | function | * Neon intrinsic unsafe | |
| 1881 | core::core_arch::arm_shared::neon::generated | vst1_lane_p8 | function | * Neon intrinsic unsafe | |
| 1882 | core::core_arch::arm_shared::neon::generated | vst1_lane_s16 | function | * Neon intrinsic unsafe | |
| 1883 | core::core_arch::arm_shared::neon::generated | vst1_lane_s32 | function | * Neon intrinsic unsafe | |
| 1884 | core::core_arch::arm_shared::neon::generated | vst1_lane_s64 | function | * Neon intrinsic unsafe | |
| 1885 | core::core_arch::arm_shared::neon::generated | vst1_lane_s8 | function | * Neon intrinsic unsafe | |
| 1886 | core::core_arch::arm_shared::neon::generated | vst1_lane_u16 | function | * Neon intrinsic unsafe | |
| 1887 | core::core_arch::arm_shared::neon::generated | vst1_lane_u32 | function | * Neon intrinsic unsafe | |
| 1888 | core::core_arch::arm_shared::neon::generated | vst1_lane_u64 | function | * Neon intrinsic unsafe | |
| 1889 | core::core_arch::arm_shared::neon::generated | vst1_lane_u8 | function | * Neon intrinsic unsafe | |
| 1890 | core::core_arch::arm_shared::neon::generated | vst1_p16_x2 | function | * Neon intrinsic unsafe | |
| 1891 | core::core_arch::arm_shared::neon::generated | vst1_p16_x3 | function | * Neon intrinsic unsafe | |
| 1892 | core::core_arch::arm_shared::neon::generated | vst1_p16_x4 | function | * Neon intrinsic unsafe | |
| 1893 | core::core_arch::arm_shared::neon::generated | vst1_p64_x2 | function | * Neon intrinsic unsafe | |
| 1894 | core::core_arch::arm_shared::neon::generated | vst1_p64_x3 | function | * Neon intrinsic unsafe | |
| 1895 | core::core_arch::arm_shared::neon::generated | vst1_p64_x4 | function | * Neon intrinsic unsafe | |
| 1896 | core::core_arch::arm_shared::neon::generated | vst1_p8_x2 | function | * Neon intrinsic unsafe | |
| 1897 | core::core_arch::arm_shared::neon::generated | vst1_p8_x3 | function | * Neon intrinsic unsafe | |
| 1898 | core::core_arch::arm_shared::neon::generated | vst1_p8_x4 | function | * Neon intrinsic unsafe | |
| 1899 | core::core_arch::arm_shared::neon::generated | vst1_s16_x2 | function | * Neon intrinsic unsafe | |
| 1900 | core::core_arch::arm_shared::neon::generated | vst1_s16_x3 | function | * Neon intrinsic unsafe | |
| 1901 | core::core_arch::arm_shared::neon::generated | vst1_s16_x4 | function | * Neon intrinsic unsafe | |
| 1902 | core::core_arch::arm_shared::neon::generated | vst1_s32_x2 | function | * Neon intrinsic unsafe | |
| 1903 | core::core_arch::arm_shared::neon::generated | vst1_s32_x3 | function | * Neon intrinsic unsafe | |
| 1904 | core::core_arch::arm_shared::neon::generated | vst1_s32_x4 | function | * Neon intrinsic unsafe | |
| 1905 | core::core_arch::arm_shared::neon::generated | vst1_s64_x2 | function | * Neon intrinsic unsafe | |
| 1906 | core::core_arch::arm_shared::neon::generated | vst1_s64_x3 | function | * Neon intrinsic unsafe | |
| 1907 | core::core_arch::arm_shared::neon::generated | vst1_s64_x4 | function | * Neon intrinsic unsafe | |
| 1908 | core::core_arch::arm_shared::neon::generated | vst1_s8_x2 | function | * Neon intrinsic unsafe | |
| 1909 | core::core_arch::arm_shared::neon::generated | vst1_s8_x3 | function | * Neon intrinsic unsafe | |
| 1910 | core::core_arch::arm_shared::neon::generated | vst1_s8_x4 | function | * Neon intrinsic unsafe | |
| 1911 | core::core_arch::arm_shared::neon::generated | vst1_u16_x2 | function | * Neon intrinsic unsafe | |
| 1912 | core::core_arch::arm_shared::neon::generated | vst1_u16_x3 | function | * Neon intrinsic unsafe | |
| 1913 | core::core_arch::arm_shared::neon::generated | vst1_u16_x4 | function | * Neon intrinsic unsafe | |
| 1914 | core::core_arch::arm_shared::neon::generated | vst1_u32_x2 | function | * Neon intrinsic unsafe | |
| 1915 | core::core_arch::arm_shared::neon::generated | vst1_u32_x3 | function | * Neon intrinsic unsafe | |
| 1916 | core::core_arch::arm_shared::neon::generated | vst1_u32_x4 | function | * Neon intrinsic unsafe | |
| 1917 | core::core_arch::arm_shared::neon::generated | vst1_u64_x2 | function | * Neon intrinsic unsafe | |
| 1918 | core::core_arch::arm_shared::neon::generated | vst1_u64_x3 | function | * Neon intrinsic unsafe | |
| 1919 | core::core_arch::arm_shared::neon::generated | vst1_u64_x4 | function | * Neon intrinsic unsafe | |
| 1920 | core::core_arch::arm_shared::neon::generated | vst1_u8_x2 | function | * Neon intrinsic unsafe | |
| 1921 | core::core_arch::arm_shared::neon::generated | vst1_u8_x3 | function | * Neon intrinsic unsafe | |
| 1922 | core::core_arch::arm_shared::neon::generated | vst1_u8_x4 | function | * Neon intrinsic unsafe | |
| 1923 | core::core_arch::arm_shared::neon::generated | vst1q_f16_x2 | function | * Neon intrinsic unsafe | |
| 1924 | core::core_arch::arm_shared::neon::generated | vst1q_f16_x3 | function | * Neon intrinsic unsafe | |
| 1925 | core::core_arch::arm_shared::neon::generated | vst1q_f16_x4 | function | * Neon intrinsic unsafe | |
| 1926 | core::core_arch::arm_shared::neon::generated | vst1q_f32_x2 | function | * Neon intrinsic unsafe | |
| 1927 | core::core_arch::arm_shared::neon::generated | vst1q_f32_x3 | function | * Neon intrinsic unsafe | |
| 1928 | core::core_arch::arm_shared::neon::generated | vst1q_f32_x4 | function | * Neon intrinsic unsafe | |
| 1929 | core::core_arch::arm_shared::neon::generated | vst1q_lane_f16 | function | * Neon intrinsic unsafe | |
| 1930 | core::core_arch::arm_shared::neon::generated | vst1q_lane_f32 | function | * Neon intrinsic unsafe | |
| 1931 | core::core_arch::arm_shared::neon::generated | vst1q_lane_p16 | function | * Neon intrinsic unsafe | |
| 1932 | core::core_arch::arm_shared::neon::generated | vst1q_lane_p64 | function | * Neon intrinsic unsafe | |
| 1933 | core::core_arch::arm_shared::neon::generated | vst1q_lane_p8 | function | * Neon intrinsic unsafe | |
| 1934 | core::core_arch::arm_shared::neon::generated | vst1q_lane_s16 | function | * Neon intrinsic unsafe | |
| 1935 | core::core_arch::arm_shared::neon::generated | vst1q_lane_s32 | function | * Neon intrinsic unsafe | |
| 1936 | core::core_arch::arm_shared::neon::generated | vst1q_lane_s64 | function | * Neon intrinsic unsafe | |
| 1937 | core::core_arch::arm_shared::neon::generated | vst1q_lane_s8 | function | * Neon intrinsic unsafe | |
| 1938 | core::core_arch::arm_shared::neon::generated | vst1q_lane_u16 | function | * Neon intrinsic unsafe | |
| 1939 | core::core_arch::arm_shared::neon::generated | vst1q_lane_u32 | function | * Neon intrinsic unsafe | |
| 1940 | core::core_arch::arm_shared::neon::generated | vst1q_lane_u64 | function | * Neon intrinsic unsafe | |
| 1941 | core::core_arch::arm_shared::neon::generated | vst1q_lane_u8 | function | * Neon intrinsic unsafe | |
| 1942 | core::core_arch::arm_shared::neon::generated | vst1q_p16_x2 | function | * Neon intrinsic unsafe | |
| 1943 | core::core_arch::arm_shared::neon::generated | vst1q_p16_x3 | function | * Neon intrinsic unsafe | |
| 1944 | core::core_arch::arm_shared::neon::generated | vst1q_p16_x4 | function | * Neon intrinsic unsafe | |
| 1945 | core::core_arch::arm_shared::neon::generated | vst1q_p64_x2 | function | * Neon intrinsic unsafe | |
| 1946 | core::core_arch::arm_shared::neon::generated | vst1q_p64_x3 | function | * Neon intrinsic unsafe | |
| 1947 | core::core_arch::arm_shared::neon::generated | vst1q_p64_x4 | function | * Neon intrinsic unsafe | |
| 1948 | core::core_arch::arm_shared::neon::generated | vst1q_p8_x2 | function | * Neon intrinsic unsafe | |
| 1949 | core::core_arch::arm_shared::neon::generated | vst1q_p8_x3 | function | * Neon intrinsic unsafe | |
| 1950 | core::core_arch::arm_shared::neon::generated | vst1q_p8_x4 | function | * Neon intrinsic unsafe | |
| 1951 | core::core_arch::arm_shared::neon::generated | vst1q_s16_x2 | function | * Neon intrinsic unsafe | |
| 1952 | core::core_arch::arm_shared::neon::generated | vst1q_s16_x3 | function | * Neon intrinsic unsafe | |
| 1953 | core::core_arch::arm_shared::neon::generated | vst1q_s16_x4 | function | * Neon intrinsic unsafe | |
| 1954 | core::core_arch::arm_shared::neon::generated | vst1q_s32_x2 | function | * Neon intrinsic unsafe | |
| 1955 | core::core_arch::arm_shared::neon::generated | vst1q_s32_x3 | function | * Neon intrinsic unsafe | |
| 1956 | core::core_arch::arm_shared::neon::generated | vst1q_s32_x4 | function | * Neon intrinsic unsafe | |
| 1957 | core::core_arch::arm_shared::neon::generated | vst1q_s64_x2 | function | * Neon intrinsic unsafe | |
| 1958 | core::core_arch::arm_shared::neon::generated | vst1q_s64_x3 | function | * Neon intrinsic unsafe | |
| 1959 | core::core_arch::arm_shared::neon::generated | vst1q_s64_x4 | function | * Neon intrinsic unsafe | |
| 1960 | core::core_arch::arm_shared::neon::generated | vst1q_s8_x2 | function | * Neon intrinsic unsafe | |
| 1961 | core::core_arch::arm_shared::neon::generated | vst1q_s8_x3 | function | * Neon intrinsic unsafe | |
| 1962 | core::core_arch::arm_shared::neon::generated | vst1q_s8_x4 | function | * Neon intrinsic unsafe | |
| 1963 | core::core_arch::arm_shared::neon::generated | vst1q_u16_x2 | function | * Neon intrinsic unsafe | |
| 1964 | core::core_arch::arm_shared::neon::generated | vst1q_u16_x3 | function | * Neon intrinsic unsafe | |
| 1965 | core::core_arch::arm_shared::neon::generated | vst1q_u16_x4 | function | * Neon intrinsic unsafe | |
| 1966 | core::core_arch::arm_shared::neon::generated | vst1q_u32_x2 | function | * Neon intrinsic unsafe | |
| 1967 | core::core_arch::arm_shared::neon::generated | vst1q_u32_x3 | function | * Neon intrinsic unsafe | |
| 1968 | core::core_arch::arm_shared::neon::generated | vst1q_u32_x4 | function | * Neon intrinsic unsafe | |
| 1969 | core::core_arch::arm_shared::neon::generated | vst1q_u64_x2 | function | * Neon intrinsic unsafe | |
| 1970 | core::core_arch::arm_shared::neon::generated | vst1q_u64_x3 | function | * Neon intrinsic unsafe | |
| 1971 | core::core_arch::arm_shared::neon::generated | vst1q_u64_x4 | function | * Neon intrinsic unsafe | |
| 1972 | core::core_arch::arm_shared::neon::generated | vst1q_u8_x2 | function | * Neon intrinsic unsafe | |
| 1973 | core::core_arch::arm_shared::neon::generated | vst1q_u8_x3 | function | * Neon intrinsic unsafe | |
| 1974 | core::core_arch::arm_shared::neon::generated | vst1q_u8_x4 | function | * Neon intrinsic unsafe | |
| 1975 | core::core_arch::arm_shared::neon::generated | vst2_f16 | function | * Neon intrinsic unsafe | |
| 1976 | core::core_arch::arm_shared::neon::generated | vst2_f32 | function | * Neon intrinsic unsafe | |
| 1977 | core::core_arch::arm_shared::neon::generated | vst2_lane_f16 | function | * Neon intrinsic unsafe | |
| 1978 | core::core_arch::arm_shared::neon::generated | vst2_lane_f32 | function | * Neon intrinsic unsafe | |
| 1979 | core::core_arch::arm_shared::neon::generated | vst2_lane_p16 | function | * Neon intrinsic unsafe | |
| 1980 | core::core_arch::arm_shared::neon::generated | vst2_lane_p8 | function | * Neon intrinsic unsafe | |
| 1981 | core::core_arch::arm_shared::neon::generated | vst2_lane_s16 | function | * Neon intrinsic unsafe | |
| 1982 | core::core_arch::arm_shared::neon::generated | vst2_lane_s32 | function | * Neon intrinsic unsafe | |
| 1983 | core::core_arch::arm_shared::neon::generated | vst2_lane_s8 | function | * Neon intrinsic unsafe | |
| 1984 | core::core_arch::arm_shared::neon::generated | vst2_lane_u16 | function | * Neon intrinsic unsafe | |
| 1985 | core::core_arch::arm_shared::neon::generated | vst2_lane_u32 | function | * Neon intrinsic unsafe | |
| 1986 | core::core_arch::arm_shared::neon::generated | vst2_lane_u8 | function | * Neon intrinsic unsafe | |
| 1987 | core::core_arch::arm_shared::neon::generated | vst2_p16 | function | * Neon intrinsic unsafe | |
| 1988 | core::core_arch::arm_shared::neon::generated | vst2_p64 | function | * Neon intrinsic unsafe | |
| 1989 | core::core_arch::arm_shared::neon::generated | vst2_p8 | function | * Neon intrinsic unsafe | |
| 1990 | core::core_arch::arm_shared::neon::generated | vst2_s16 | function | * Neon intrinsic unsafe | |
| 1991 | core::core_arch::arm_shared::neon::generated | vst2_s32 | function | * Neon intrinsic unsafe | |
| 1992 | core::core_arch::arm_shared::neon::generated | vst2_s64 | function | * Neon intrinsic unsafe | |
| 1993 | core::core_arch::arm_shared::neon::generated | vst2_s8 | function | * Neon intrinsic unsafe | |
| 1994 | core::core_arch::arm_shared::neon::generated | vst2_u16 | function | * Neon intrinsic unsafe | |
| 1995 | core::core_arch::arm_shared::neon::generated | vst2_u32 | function | * Neon intrinsic unsafe | |
| 1996 | core::core_arch::arm_shared::neon::generated | vst2_u64 | function | * Neon intrinsic unsafe | |
| 1997 | core::core_arch::arm_shared::neon::generated | vst2_u8 | function | * Neon intrinsic unsafe | |
| 1998 | core::core_arch::arm_shared::neon::generated | vst2q_f16 | function | * Neon intrinsic unsafe | |
| 1999 | core::core_arch::arm_shared::neon::generated | vst2q_f32 | function | * Neon intrinsic unsafe | |
| 2000 | core::core_arch::arm_shared::neon::generated | vst2q_lane_f16 | function | * Neon intrinsic unsafe | |
| 2001 | core::core_arch::arm_shared::neon::generated | vst2q_lane_f32 | function | * Neon intrinsic unsafe | |
| 2002 | core::core_arch::arm_shared::neon::generated | vst2q_lane_p16 | function | * Neon intrinsic unsafe | |
| 2003 | core::core_arch::arm_shared::neon::generated | vst2q_lane_s16 | function | * Neon intrinsic unsafe | |
| 2004 | core::core_arch::arm_shared::neon::generated | vst2q_lane_s32 | function | * Neon intrinsic unsafe | |
| 2005 | core::core_arch::arm_shared::neon::generated | vst2q_lane_u16 | function | * Neon intrinsic unsafe | |
| 2006 | core::core_arch::arm_shared::neon::generated | vst2q_lane_u32 | function | * Neon intrinsic unsafe | |
| 2007 | core::core_arch::arm_shared::neon::generated | vst2q_p16 | function | * Neon intrinsic unsafe | |
| 2008 | core::core_arch::arm_shared::neon::generated | vst2q_p8 | function | * Neon intrinsic unsafe | |
| 2009 | core::core_arch::arm_shared::neon::generated | vst2q_s16 | function | * Neon intrinsic unsafe | |
| 2010 | core::core_arch::arm_shared::neon::generated | vst2q_s32 | function | * Neon intrinsic unsafe | |
| 2011 | core::core_arch::arm_shared::neon::generated | vst2q_s8 | function | * Neon intrinsic unsafe | |
| 2012 | core::core_arch::arm_shared::neon::generated | vst2q_u16 | function | * Neon intrinsic unsafe | |
| 2013 | core::core_arch::arm_shared::neon::generated | vst2q_u32 | function | * Neon intrinsic unsafe | |
| 2014 | core::core_arch::arm_shared::neon::generated | vst2q_u8 | function | * Neon intrinsic unsafe | |
| 2015 | core::core_arch::arm_shared::neon::generated | vst3_f16 | function | * Neon intrinsic unsafe | |
| 2016 | core::core_arch::arm_shared::neon::generated | vst3_f32 | function | * Neon intrinsic unsafe | |
| 2017 | core::core_arch::arm_shared::neon::generated | vst3_lane_f16 | function | * Neon intrinsic unsafe | |
| 2018 | core::core_arch::arm_shared::neon::generated | vst3_lane_f32 | function | * Neon intrinsic unsafe | |
| 2019 | core::core_arch::arm_shared::neon::generated | vst3_lane_p16 | function | * Neon intrinsic unsafe | |
| 2020 | core::core_arch::arm_shared::neon::generated | vst3_lane_p8 | function | * Neon intrinsic unsafe | |
| 2021 | core::core_arch::arm_shared::neon::generated | vst3_lane_s16 | function | * Neon intrinsic unsafe | |
| 2022 | core::core_arch::arm_shared::neon::generated | vst3_lane_s32 | function | * Neon intrinsic unsafe | |
| 2023 | core::core_arch::arm_shared::neon::generated | vst3_lane_s8 | function | * Neon intrinsic unsafe | |
| 2024 | core::core_arch::arm_shared::neon::generated | vst3_lane_u16 | function | * Neon intrinsic unsafe | |
| 2025 | core::core_arch::arm_shared::neon::generated | vst3_lane_u32 | function | * Neon intrinsic unsafe | |
| 2026 | core::core_arch::arm_shared::neon::generated | vst3_lane_u8 | function | * Neon intrinsic unsafe | |
| 2027 | core::core_arch::arm_shared::neon::generated | vst3_p16 | function | * Neon intrinsic unsafe | |
| 2028 | core::core_arch::arm_shared::neon::generated | vst3_p64 | function | * Neon intrinsic unsafe | |
| 2029 | core::core_arch::arm_shared::neon::generated | vst3_p8 | function | * Neon intrinsic unsafe | |
| 2030 | core::core_arch::arm_shared::neon::generated | vst3_s16 | function | * Neon intrinsic unsafe | |
| 2031 | core::core_arch::arm_shared::neon::generated | vst3_s32 | function | * Neon intrinsic unsafe | |
| 2032 | core::core_arch::arm_shared::neon::generated | vst3_s64 | function | * Neon intrinsic unsafe | |
| 2033 | core::core_arch::arm_shared::neon::generated | vst3_s8 | function | * Neon intrinsic unsafe | |
| 2034 | core::core_arch::arm_shared::neon::generated | vst3_u16 | function | * Neon intrinsic unsafe | |
| 2035 | core::core_arch::arm_shared::neon::generated | vst3_u32 | function | * Neon intrinsic unsafe | |
| 2036 | core::core_arch::arm_shared::neon::generated | vst3_u64 | function | * Neon intrinsic unsafe | |
| 2037 | core::core_arch::arm_shared::neon::generated | vst3_u8 | function | * Neon intrinsic unsafe | |
| 2038 | core::core_arch::arm_shared::neon::generated | vst3q_f16 | function | * Neon intrinsic unsafe | |
| 2039 | core::core_arch::arm_shared::neon::generated | vst3q_f32 | function | * Neon intrinsic unsafe | |
| 2040 | core::core_arch::arm_shared::neon::generated | vst3q_lane_f16 | function | * Neon intrinsic unsafe | |
| 2041 | core::core_arch::arm_shared::neon::generated | vst3q_lane_f32 | function | * Neon intrinsic unsafe | |
| 2042 | core::core_arch::arm_shared::neon::generated | vst3q_lane_p16 | function | * Neon intrinsic unsafe | |
| 2043 | core::core_arch::arm_shared::neon::generated | vst3q_lane_s16 | function | * Neon intrinsic unsafe | |
| 2044 | core::core_arch::arm_shared::neon::generated | vst3q_lane_s32 | function | * Neon intrinsic unsafe | |
| 2045 | core::core_arch::arm_shared::neon::generated | vst3q_lane_u16 | function | * Neon intrinsic unsafe | |
| 2046 | core::core_arch::arm_shared::neon::generated | vst3q_lane_u32 | function | * Neon intrinsic unsafe | |
| 2047 | core::core_arch::arm_shared::neon::generated | vst3q_p16 | function | * Neon intrinsic unsafe | |
| 2048 | core::core_arch::arm_shared::neon::generated | vst3q_p8 | function | * Neon intrinsic unsafe | |
| 2049 | core::core_arch::arm_shared::neon::generated | vst3q_s16 | function | * Neon intrinsic unsafe | |
| 2050 | core::core_arch::arm_shared::neon::generated | vst3q_s32 | function | * Neon intrinsic unsafe | |
| 2051 | core::core_arch::arm_shared::neon::generated | vst3q_s8 | function | * Neon intrinsic unsafe | |
| 2052 | core::core_arch::arm_shared::neon::generated | vst3q_u16 | function | * Neon intrinsic unsafe | |
| 2053 | core::core_arch::arm_shared::neon::generated | vst3q_u32 | function | * Neon intrinsic unsafe | |
| 2054 | core::core_arch::arm_shared::neon::generated | vst3q_u8 | function | * Neon intrinsic unsafe | |
| 2055 | core::core_arch::arm_shared::neon::generated | vst4_f16 | function | * Neon intrinsic unsafe | |
| 2056 | core::core_arch::arm_shared::neon::generated | vst4_f32 | function | * Neon intrinsic unsafe | |
| 2057 | core::core_arch::arm_shared::neon::generated | vst4_lane_f16 | function | * Neon intrinsic unsafe | |
| 2058 | core::core_arch::arm_shared::neon::generated | vst4_lane_f32 | function | * Neon intrinsic unsafe | |
| 2059 | core::core_arch::arm_shared::neon::generated | vst4_lane_p16 | function | * Neon intrinsic unsafe | |
| 2060 | core::core_arch::arm_shared::neon::generated | vst4_lane_p8 | function | * Neon intrinsic unsafe | |
| 2061 | core::core_arch::arm_shared::neon::generated | vst4_lane_s16 | function | * Neon intrinsic unsafe | |
| 2062 | core::core_arch::arm_shared::neon::generated | vst4_lane_s32 | function | * Neon intrinsic unsafe | |
| 2063 | core::core_arch::arm_shared::neon::generated | vst4_lane_s8 | function | * Neon intrinsic unsafe | |
| 2064 | core::core_arch::arm_shared::neon::generated | vst4_lane_u16 | function | * Neon intrinsic unsafe | |
| 2065 | core::core_arch::arm_shared::neon::generated | vst4_lane_u32 | function | * Neon intrinsic unsafe | |
| 2066 | core::core_arch::arm_shared::neon::generated | vst4_lane_u8 | function | * Neon intrinsic unsafe | |
| 2067 | core::core_arch::arm_shared::neon::generated | vst4_p16 | function | * Neon intrinsic unsafe | |
| 2068 | core::core_arch::arm_shared::neon::generated | vst4_p64 | function | * Neon intrinsic unsafe | |
| 2069 | core::core_arch::arm_shared::neon::generated | vst4_p8 | function | * Neon intrinsic unsafe | |
| 2070 | core::core_arch::arm_shared::neon::generated | vst4_s16 | function | * Neon intrinsic unsafe | |
| 2071 | core::core_arch::arm_shared::neon::generated | vst4_s32 | function | * Neon intrinsic unsafe | |
| 2072 | core::core_arch::arm_shared::neon::generated | vst4_s64 | function | * Neon intrinsic unsafe | |
| 2073 | core::core_arch::arm_shared::neon::generated | vst4_s8 | function | * Neon intrinsic unsafe | |
| 2074 | core::core_arch::arm_shared::neon::generated | vst4_u16 | function | * Neon intrinsic unsafe | |
| 2075 | core::core_arch::arm_shared::neon::generated | vst4_u32 | function | * Neon intrinsic unsafe | |
| 2076 | core::core_arch::arm_shared::neon::generated | vst4_u64 | function | * Neon intrinsic unsafe | |
| 2077 | core::core_arch::arm_shared::neon::generated | vst4_u8 | function | * Neon intrinsic unsafe | |
| 2078 | core::core_arch::arm_shared::neon::generated | vst4q_f16 | function | * Neon intrinsic unsafe | |
| 2079 | core::core_arch::arm_shared::neon::generated | vst4q_f32 | function | * Neon intrinsic unsafe | |
| 2080 | core::core_arch::arm_shared::neon::generated | vst4q_lane_f16 | function | * Neon intrinsic unsafe | |
| 2081 | core::core_arch::arm_shared::neon::generated | vst4q_lane_f32 | function | * Neon intrinsic unsafe | |
| 2082 | core::core_arch::arm_shared::neon::generated | vst4q_lane_p16 | function | * Neon intrinsic unsafe | |
| 2083 | core::core_arch::arm_shared::neon::generated | vst4q_lane_s16 | function | * Neon intrinsic unsafe | |
| 2084 | core::core_arch::arm_shared::neon::generated | vst4q_lane_s32 | function | * Neon intrinsic unsafe | |
| 2085 | core::core_arch::arm_shared::neon::generated | vst4q_lane_u16 | function | * Neon intrinsic unsafe | |
| 2086 | core::core_arch::arm_shared::neon::generated | vst4q_lane_u32 | function | * Neon intrinsic unsafe | |
| 2087 | core::core_arch::arm_shared::neon::generated | vst4q_p16 | function | * Neon intrinsic unsafe | |
| 2088 | core::core_arch::arm_shared::neon::generated | vst4q_p8 | function | * Neon intrinsic unsafe | |
| 2089 | core::core_arch::arm_shared::neon::generated | vst4q_s16 | function | * Neon intrinsic unsafe | |
| 2090 | core::core_arch::arm_shared::neon::generated | vst4q_s32 | function | * Neon intrinsic unsafe | |
| 2091 | core::core_arch::arm_shared::neon::generated | vst4q_s8 | function | * Neon intrinsic unsafe | |
| 2092 | core::core_arch::arm_shared::neon::generated | vst4q_u16 | function | * Neon intrinsic unsafe | |
| 2093 | core::core_arch::arm_shared::neon::generated | vst4q_u32 | function | * Neon intrinsic unsafe | |
| 2094 | core::core_arch::arm_shared::neon::generated | vst4q_u8 | function | * Neon intrinsic unsafe | |
| 2095 | core::core_arch::arm_shared::neon::generated | vstrq_p128 | function | * Neon intrinsic unsafe | |
| 2096 | core::core_arch::hexagon::v128 | Q6_Q_and_QQ | function | ||
| 2097 | core::core_arch::hexagon::v128 | Q6_Q_and_QQn | function | ||
| 2098 | core::core_arch::hexagon::v128 | Q6_Q_not_Q | function | ||
| 2099 | core::core_arch::hexagon::v128 | Q6_Q_or_QQ | function | ||
| 2100 | core::core_arch::hexagon::v128 | Q6_Q_or_QQn | function | ||
| 2101 | core::core_arch::hexagon::v128 | Q6_Q_vand_VR | function | ||
| 2102 | core::core_arch::hexagon::v128 | Q6_Q_vandor_QVR | function | ||
| 2103 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_eq_VbVb | function | ||
| 2104 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_eq_VhVh | function | ||
| 2105 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_eq_VwVw | function | ||
| 2106 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_eqand_QVbVb | function | ||
| 2107 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_eqand_QVhVh | function | ||
| 2108 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_eqand_QVwVw | function | ||
| 2109 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_eqor_QVbVb | function | ||
| 2110 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_eqor_QVhVh | function | ||
| 2111 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_eqor_QVwVw | function | ||
| 2112 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_eqxacc_QVbVb | function | ||
| 2113 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_eqxacc_QVhVh | function | ||
| 2114 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_eqxacc_QVwVw | function | ||
| 2115 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gt_VbVb | function | ||
| 2116 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gt_VhVh | function | ||
| 2117 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gt_VhfVhf | function | ||
| 2118 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gt_VsfVsf | function | ||
| 2119 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gt_VubVub | function | ||
| 2120 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gt_VuhVuh | function | ||
| 2121 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gt_VuwVuw | function | ||
| 2122 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gt_VwVw | function | ||
| 2123 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtand_QVbVb | function | ||
| 2124 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtand_QVhVh | function | ||
| 2125 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtand_QVhfVhf | function | ||
| 2126 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtand_QVsfVsf | function | ||
| 2127 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtand_QVubVub | function | ||
| 2128 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtand_QVuhVuh | function | ||
| 2129 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtand_QVuwVuw | function | ||
| 2130 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtand_QVwVw | function | ||
| 2131 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtor_QVbVb | function | ||
| 2132 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtor_QVhVh | function | ||
| 2133 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtor_QVhfVhf | function | ||
| 2134 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtor_QVsfVsf | function | ||
| 2135 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtor_QVubVub | function | ||
| 2136 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtor_QVuhVuh | function | ||
| 2137 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtor_QVuwVuw | function | ||
| 2138 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtor_QVwVw | function | ||
| 2139 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtxacc_QVbVb | function | ||
| 2140 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtxacc_QVhVh | function | ||
| 2141 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtxacc_QVhfVhf | function | ||
| 2142 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtxacc_QVsfVsf | function | ||
| 2143 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtxacc_QVubVub | function | ||
| 2144 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtxacc_QVuhVuh | function | ||
| 2145 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtxacc_QVuwVuw | function | ||
| 2146 | core::core_arch::hexagon::v128 | Q6_Q_vcmp_gtxacc_QVwVw | function | ||
| 2147 | core::core_arch::hexagon::v128 | Q6_Q_vsetq2_R | function | ||
| 2148 | core::core_arch::hexagon::v128 | Q6_Q_vsetq_R | function | ||
| 2149 | core::core_arch::hexagon::v128 | Q6_Q_xor_QQ | function | ||
| 2150 | core::core_arch::hexagon::v128 | Q6_Qb_vshuffe_QhQh | function | ||
| 2151 | core::core_arch::hexagon::v128 | Q6_Qh_vshuffe_QwQw | function | ||
| 2152 | core::core_arch::hexagon::v128 | Q6_R_vextract_VR | function | ||
| 2153 | core::core_arch::hexagon::v128 | Q6_V_equals_V | function | ||
| 2154 | core::core_arch::hexagon::v128 | Q6_V_hi_W | function | ||
| 2155 | core::core_arch::hexagon::v128 | Q6_V_lo_W | function | ||
| 2156 | core::core_arch::hexagon::v128 | Q6_V_vabs_V | function | ||
| 2157 | core::core_arch::hexagon::v128 | Q6_V_valign_VVI | function | ||
| 2158 | core::core_arch::hexagon::v128 | Q6_V_valign_VVR | function | ||
| 2159 | core::core_arch::hexagon::v128 | Q6_V_vand_QR | function | ||
| 2160 | core::core_arch::hexagon::v128 | Q6_V_vand_QV | function | ||
| 2161 | core::core_arch::hexagon::v128 | Q6_V_vand_QnR | function | ||
| 2162 | core::core_arch::hexagon::v128 | Q6_V_vand_QnV | function | ||
| 2163 | core::core_arch::hexagon::v128 | Q6_V_vand_VV | function | ||
| 2164 | core::core_arch::hexagon::v128 | Q6_V_vandor_VQR | function | ||
| 2165 | core::core_arch::hexagon::v128 | Q6_V_vandor_VQnR | function | ||
| 2166 | core::core_arch::hexagon::v128 | Q6_V_vdelta_VV | function | ||
| 2167 | core::core_arch::hexagon::v128 | Q6_V_vfmax_VV | function | ||
| 2168 | core::core_arch::hexagon::v128 | Q6_V_vfmin_VV | function | ||
| 2169 | core::core_arch::hexagon::v128 | Q6_V_vfneg_V | function | ||
| 2170 | core::core_arch::hexagon::v128 | Q6_V_vgetqfext_VR | function | ||
| 2171 | core::core_arch::hexagon::v128 | Q6_V_vlalign_VVI | function | ||
| 2172 | core::core_arch::hexagon::v128 | Q6_V_vlalign_VVR | function | ||
| 2173 | core::core_arch::hexagon::v128 | Q6_V_vmux_QVV | function | ||
| 2174 | core::core_arch::hexagon::v128 | Q6_V_vnot_V | function | ||
| 2175 | core::core_arch::hexagon::v128 | Q6_V_vor_VV | function | ||
| 2176 | core::core_arch::hexagon::v128 | Q6_V_vrdelta_VV | function | ||
| 2177 | core::core_arch::hexagon::v128 | Q6_V_vror_VR | function | ||
| 2178 | core::core_arch::hexagon::v128 | Q6_V_vsetqfext_VR | function | ||
| 2179 | core::core_arch::hexagon::v128 | Q6_V_vsplat_R | function | ||
| 2180 | core::core_arch::hexagon::v128 | Q6_V_vxor_VV | function | ||
| 2181 | core::core_arch::hexagon::v128 | Q6_V_vzero | function | ||
| 2182 | core::core_arch::hexagon::v128 | Q6_Vb_condacc_QVbVb | function | ||
| 2183 | core::core_arch::hexagon::v128 | Q6_Vb_condacc_QnVbVb | function | ||
| 2184 | core::core_arch::hexagon::v128 | Q6_Vb_condnac_QVbVb | function | ||
| 2185 | core::core_arch::hexagon::v128 | Q6_Vb_condnac_QnVbVb | function | ||
| 2186 | core::core_arch::hexagon::v128 | Q6_Vb_prefixsum_Q | function | ||
| 2187 | core::core_arch::hexagon::v128 | Q6_Vb_vabs_Vb | function | ||
| 2188 | core::core_arch::hexagon::v128 | Q6_Vb_vabs_Vb_sat | function | ||
| 2189 | core::core_arch::hexagon::v128 | Q6_Vb_vadd_VbVb | function | ||
| 2190 | core::core_arch::hexagon::v128 | Q6_Vb_vadd_VbVb_sat | function | ||
| 2191 | core::core_arch::hexagon::v128 | Q6_Vb_vasr_VhVhR_rnd_sat | function | ||
| 2192 | core::core_arch::hexagon::v128 | Q6_Vb_vasr_VhVhR_sat | function | ||
| 2193 | core::core_arch::hexagon::v128 | Q6_Vb_vavg_VbVb | function | ||
| 2194 | core::core_arch::hexagon::v128 | Q6_Vb_vavg_VbVb_rnd | function | ||
| 2195 | core::core_arch::hexagon::v128 | Q6_Vb_vcvt_VhfVhf | function | ||
| 2196 | core::core_arch::hexagon::v128 | Q6_Vb_vdeal_Vb | function | ||
| 2197 | core::core_arch::hexagon::v128 | Q6_Vb_vdeale_VbVb | function | ||
| 2198 | core::core_arch::hexagon::v128 | Q6_Vb_vlut32_VbVbI | function | ||
| 2199 | core::core_arch::hexagon::v128 | Q6_Vb_vlut32_VbVbR | function | ||
| 2200 | core::core_arch::hexagon::v128 | Q6_Vb_vlut32_VbVbR_nomatch | function | ||
| 2201 | core::core_arch::hexagon::v128 | Q6_Vb_vlut32or_VbVbVbI | function | ||
| 2202 | core::core_arch::hexagon::v128 | Q6_Vb_vlut32or_VbVbVbR | function | ||
| 2203 | core::core_arch::hexagon::v128 | Q6_Vb_vmax_VbVb | function | ||
| 2204 | core::core_arch::hexagon::v128 | Q6_Vb_vmin_VbVb | function | ||
| 2205 | core::core_arch::hexagon::v128 | Q6_Vb_vnavg_VbVb | function | ||
| 2206 | core::core_arch::hexagon::v128 | Q6_Vb_vnavg_VubVub | function | ||
| 2207 | core::core_arch::hexagon::v128 | Q6_Vb_vpack_VhVh_sat | function | ||
| 2208 | core::core_arch::hexagon::v128 | Q6_Vb_vpacke_VhVh | function | ||
| 2209 | core::core_arch::hexagon::v128 | Q6_Vb_vpacko_VhVh | function | ||
| 2210 | core::core_arch::hexagon::v128 | Q6_Vb_vround_VhVh_sat | function | ||
| 2211 | core::core_arch::hexagon::v128 | Q6_Vb_vshuff_Vb | function | ||
| 2212 | core::core_arch::hexagon::v128 | Q6_Vb_vshuffe_VbVb | function | ||
| 2213 | core::core_arch::hexagon::v128 | Q6_Vb_vshuffo_VbVb | function | ||
| 2214 | core::core_arch::hexagon::v128 | Q6_Vb_vsplat_R | function | ||
| 2215 | core::core_arch::hexagon::v128 | Q6_Vb_vsub_VbVb | function | ||
| 2216 | core::core_arch::hexagon::v128 | Q6_Vb_vsub_VbVb_sat | function | ||
| 2217 | core::core_arch::hexagon::v128 | Q6_Vh_condacc_QVhVh | function | ||
| 2218 | core::core_arch::hexagon::v128 | Q6_Vh_condacc_QnVhVh | function | ||
| 2219 | core::core_arch::hexagon::v128 | Q6_Vh_condnac_QVhVh | function | ||
| 2220 | core::core_arch::hexagon::v128 | Q6_Vh_condnac_QnVhVh | function | ||
| 2221 | core::core_arch::hexagon::v128 | Q6_Vh_equals_Vhf | function | ||
| 2222 | core::core_arch::hexagon::v128 | Q6_Vh_prefixsum_Q | function | ||
| 2223 | core::core_arch::hexagon::v128 | Q6_Vh_vabs_Vh | function | ||
| 2224 | core::core_arch::hexagon::v128 | Q6_Vh_vabs_Vh_sat | function | ||
| 2225 | core::core_arch::hexagon::v128 | Q6_Vh_vadd_VhVh | function | ||
| 2226 | core::core_arch::hexagon::v128 | Q6_Vh_vadd_VhVh_sat | function | ||
| 2227 | core::core_arch::hexagon::v128 | Q6_Vh_vadd_vclb_VhVh | function | ||
| 2228 | core::core_arch::hexagon::v128 | Q6_Vh_vasl_VhR | function | ||
| 2229 | core::core_arch::hexagon::v128 | Q6_Vh_vasl_VhVh | function | ||
| 2230 | core::core_arch::hexagon::v128 | Q6_Vh_vaslacc_VhVhR | function | ||
| 2231 | core::core_arch::hexagon::v128 | Q6_Vh_vasr_VhR | function | ||
| 2232 | core::core_arch::hexagon::v128 | Q6_Vh_vasr_VhVh | function | ||
| 2233 | core::core_arch::hexagon::v128 | Q6_Vh_vasr_VwVwR | function | ||
| 2234 | core::core_arch::hexagon::v128 | Q6_Vh_vasr_VwVwR_rnd_sat | function | ||
| 2235 | core::core_arch::hexagon::v128 | Q6_Vh_vasr_VwVwR_sat | function | ||
| 2236 | core::core_arch::hexagon::v128 | Q6_Vh_vasracc_VhVhR | function | ||
| 2237 | core::core_arch::hexagon::v128 | Q6_Vh_vavg_VhVh | function | ||
| 2238 | core::core_arch::hexagon::v128 | Q6_Vh_vavg_VhVh_rnd | function | ||
| 2239 | core::core_arch::hexagon::v128 | Q6_Vh_vcvt_Vhf | function | ||
| 2240 | core::core_arch::hexagon::v128 | Q6_Vh_vdeal_Vh | function | ||
| 2241 | core::core_arch::hexagon::v128 | Q6_Vh_vdmpy_VubRb | function | ||
| 2242 | core::core_arch::hexagon::v128 | Q6_Vh_vdmpyacc_VhVubRb | function | ||
| 2243 | core::core_arch::hexagon::v128 | Q6_Vh_vlsr_VhVh | function | ||
| 2244 | core::core_arch::hexagon::v128 | Q6_Vh_vmax_VhVh | function | ||
| 2245 | core::core_arch::hexagon::v128 | Q6_Vh_vmin_VhVh | function | ||
| 2246 | core::core_arch::hexagon::v128 | Q6_Vh_vmpy_VhRh_s1_rnd_sat | function | ||
| 2247 | core::core_arch::hexagon::v128 | Q6_Vh_vmpy_VhRh_s1_sat | function | ||
| 2248 | core::core_arch::hexagon::v128 | Q6_Vh_vmpy_VhVh_s1_rnd_sat | function | ||
| 2249 | core::core_arch::hexagon::v128 | Q6_Vh_vmpyi_VhRb | function | ||
| 2250 | core::core_arch::hexagon::v128 | Q6_Vh_vmpyi_VhVh | function | ||
| 2251 | core::core_arch::hexagon::v128 | Q6_Vh_vmpyiacc_VhVhRb | function | ||
| 2252 | core::core_arch::hexagon::v128 | Q6_Vh_vmpyiacc_VhVhVh | function | ||
| 2253 | core::core_arch::hexagon::v128 | Q6_Vh_vnavg_VhVh | function | ||
| 2254 | core::core_arch::hexagon::v128 | Q6_Vh_vnormamt_Vh | function | ||
| 2255 | core::core_arch::hexagon::v128 | Q6_Vh_vpack_VwVw_sat | function | ||
| 2256 | core::core_arch::hexagon::v128 | Q6_Vh_vpacke_VwVw | function | ||
| 2257 | core::core_arch::hexagon::v128 | Q6_Vh_vpacko_VwVw | function | ||
| 2258 | core::core_arch::hexagon::v128 | Q6_Vh_vpopcount_Vh | function | ||
| 2259 | core::core_arch::hexagon::v128 | Q6_Vh_vround_VwVw_sat | function | ||
| 2260 | core::core_arch::hexagon::v128 | Q6_Vh_vsat_VwVw | function | ||
| 2261 | core::core_arch::hexagon::v128 | Q6_Vh_vshuff_Vh | function | ||
| 2262 | core::core_arch::hexagon::v128 | Q6_Vh_vshuffe_VhVh | function | ||
| 2263 | core::core_arch::hexagon::v128 | Q6_Vh_vshuffo_VhVh | function | ||
| 2264 | core::core_arch::hexagon::v128 | Q6_Vh_vsplat_R | function | ||
| 2265 | core::core_arch::hexagon::v128 | Q6_Vh_vsub_VhVh | function | ||
| 2266 | core::core_arch::hexagon::v128 | Q6_Vh_vsub_VhVh_sat | function | ||
| 2267 | core::core_arch::hexagon::v128 | Q6_Vhf_equals_Vh | function | ||
| 2268 | core::core_arch::hexagon::v128 | Q6_Vhf_equals_Vqf16 | function | ||
| 2269 | core::core_arch::hexagon::v128 | Q6_Vhf_equals_Wqf32 | function | ||
| 2270 | core::core_arch::hexagon::v128 | Q6_Vhf_vabs_Vhf | function | ||
| 2271 | core::core_arch::hexagon::v128 | Q6_Vhf_vadd_VhfVhf | function | ||
| 2272 | core::core_arch::hexagon::v128 | Q6_Vhf_vcvt_Vh | function | ||
| 2273 | core::core_arch::hexagon::v128 | Q6_Vhf_vcvt_VsfVsf | function | ||
| 2274 | core::core_arch::hexagon::v128 | Q6_Vhf_vcvt_Vuh | function | ||
| 2275 | core::core_arch::hexagon::v128 | Q6_Vhf_vfmax_VhfVhf | function | ||
| 2276 | core::core_arch::hexagon::v128 | Q6_Vhf_vfmin_VhfVhf | function | ||
| 2277 | core::core_arch::hexagon::v128 | Q6_Vhf_vfneg_Vhf | function | ||
| 2278 | core::core_arch::hexagon::v128 | Q6_Vhf_vmax_VhfVhf | function | ||
| 2279 | core::core_arch::hexagon::v128 | Q6_Vhf_vmin_VhfVhf | function | ||
| 2280 | core::core_arch::hexagon::v128 | Q6_Vhf_vmpy_VhfVhf | function | ||
| 2281 | core::core_arch::hexagon::v128 | Q6_Vhf_vmpyacc_VhfVhfVhf | function | ||
| 2282 | core::core_arch::hexagon::v128 | Q6_Vhf_vsub_VhfVhf | function | ||
| 2283 | core::core_arch::hexagon::v128 | Q6_Vqf16_vadd_VhfVhf | function | ||
| 2284 | core::core_arch::hexagon::v128 | Q6_Vqf16_vadd_Vqf16Vhf | function | ||
| 2285 | core::core_arch::hexagon::v128 | Q6_Vqf16_vadd_Vqf16Vqf16 | function | ||
| 2286 | core::core_arch::hexagon::v128 | Q6_Vqf16_vmpy_VhfVhf | function | ||
| 2287 | core::core_arch::hexagon::v128 | Q6_Vqf16_vmpy_Vqf16Vhf | function | ||
| 2288 | core::core_arch::hexagon::v128 | Q6_Vqf16_vmpy_Vqf16Vqf16 | function | ||
| 2289 | core::core_arch::hexagon::v128 | Q6_Vqf16_vsub_VhfVhf | function | ||
| 2290 | core::core_arch::hexagon::v128 | Q6_Vqf16_vsub_Vqf16Vhf | function | ||
| 2291 | core::core_arch::hexagon::v128 | Q6_Vqf16_vsub_Vqf16Vqf16 | function | ||
| 2292 | core::core_arch::hexagon::v128 | Q6_Vqf32_vadd_Vqf32Vqf32 | function | ||
| 2293 | core::core_arch::hexagon::v128 | Q6_Vqf32_vadd_Vqf32Vsf | function | ||
| 2294 | core::core_arch::hexagon::v128 | Q6_Vqf32_vadd_VsfVsf | function | ||
| 2295 | core::core_arch::hexagon::v128 | Q6_Vqf32_vmpy_Vqf32Vqf32 | function | ||
| 2296 | core::core_arch::hexagon::v128 | Q6_Vqf32_vmpy_VsfVsf | function | ||
| 2297 | core::core_arch::hexagon::v128 | Q6_Vqf32_vsub_Vqf32Vqf32 | function | ||
| 2298 | core::core_arch::hexagon::v128 | Q6_Vqf32_vsub_Vqf32Vsf | function | ||
| 2299 | core::core_arch::hexagon::v128 | Q6_Vqf32_vsub_VsfVsf | function | ||
| 2300 | core::core_arch::hexagon::v128 | Q6_Vsf_equals_Vqf32 | function | ||
| 2301 | core::core_arch::hexagon::v128 | Q6_Vsf_equals_Vw | function | ||
| 2302 | core::core_arch::hexagon::v128 | Q6_Vsf_vabs_Vsf | function | ||
| 2303 | core::core_arch::hexagon::v128 | Q6_Vsf_vadd_VsfVsf | function | ||
| 2304 | core::core_arch::hexagon::v128 | Q6_Vsf_vdmpy_VhfVhf | function | ||
| 2305 | core::core_arch::hexagon::v128 | Q6_Vsf_vdmpyacc_VsfVhfVhf | function | ||
| 2306 | core::core_arch::hexagon::v128 | Q6_Vsf_vfmax_VsfVsf | function | ||
| 2307 | core::core_arch::hexagon::v128 | Q6_Vsf_vfmin_VsfVsf | function | ||
| 2308 | core::core_arch::hexagon::v128 | Q6_Vsf_vfneg_Vsf | function | ||
| 2309 | core::core_arch::hexagon::v128 | Q6_Vsf_vmax_VsfVsf | function | ||
| 2310 | core::core_arch::hexagon::v128 | Q6_Vsf_vmin_VsfVsf | function | ||
| 2311 | core::core_arch::hexagon::v128 | Q6_Vsf_vmpy_VsfVsf | function | ||
| 2312 | core::core_arch::hexagon::v128 | Q6_Vsf_vsub_VsfVsf | function | ||
| 2313 | core::core_arch::hexagon::v128 | Q6_Vub_vabsdiff_VubVub | function | ||
| 2314 | core::core_arch::hexagon::v128 | Q6_Vub_vadd_VubVb_sat | function | ||
| 2315 | core::core_arch::hexagon::v128 | Q6_Vub_vadd_VubVub_sat | function | ||
| 2316 | core::core_arch::hexagon::v128 | Q6_Vub_vasr_VhVhR_rnd_sat | function | ||
| 2317 | core::core_arch::hexagon::v128 | Q6_Vub_vasr_VhVhR_sat | function | ||
| 2318 | core::core_arch::hexagon::v128 | Q6_Vub_vasr_VuhVuhR_rnd_sat | function | ||
| 2319 | core::core_arch::hexagon::v128 | Q6_Vub_vasr_VuhVuhR_sat | function | ||
| 2320 | core::core_arch::hexagon::v128 | Q6_Vub_vasr_WuhVub_rnd_sat | function | ||
| 2321 | core::core_arch::hexagon::v128 | Q6_Vub_vasr_WuhVub_sat | function | ||
| 2322 | core::core_arch::hexagon::v128 | Q6_Vub_vavg_VubVub | function | ||
| 2323 | core::core_arch::hexagon::v128 | Q6_Vub_vavg_VubVub_rnd | function | ||
| 2324 | core::core_arch::hexagon::v128 | Q6_Vub_vcvt_VhfVhf | function | ||
| 2325 | core::core_arch::hexagon::v128 | Q6_Vub_vlsr_VubR | function | ||
| 2326 | core::core_arch::hexagon::v128 | Q6_Vub_vmax_VubVub | function | ||
| 2327 | core::core_arch::hexagon::v128 | Q6_Vub_vmin_VubVub | function | ||
| 2328 | core::core_arch::hexagon::v128 | Q6_Vub_vpack_VhVh_sat | function | ||
| 2329 | core::core_arch::hexagon::v128 | Q6_Vub_vround_VhVh_sat | function | ||
| 2330 | core::core_arch::hexagon::v128 | Q6_Vub_vround_VuhVuh_sat | function | ||
| 2331 | core::core_arch::hexagon::v128 | Q6_Vub_vsat_VhVh | function | ||
| 2332 | core::core_arch::hexagon::v128 | Q6_Vub_vsub_VubVb_sat | function | ||
| 2333 | core::core_arch::hexagon::v128 | Q6_Vub_vsub_VubVub_sat | function | ||
| 2334 | core::core_arch::hexagon::v128 | Q6_Vuh_vabsdiff_VhVh | function | ||
| 2335 | core::core_arch::hexagon::v128 | Q6_Vuh_vabsdiff_VuhVuh | function | ||
| 2336 | core::core_arch::hexagon::v128 | Q6_Vuh_vadd_VuhVuh_sat | function | ||
| 2337 | core::core_arch::hexagon::v128 | Q6_Vuh_vasr_VuwVuwR_rnd_sat | function | ||
| 2338 | core::core_arch::hexagon::v128 | Q6_Vuh_vasr_VuwVuwR_sat | function | ||
| 2339 | core::core_arch::hexagon::v128 | Q6_Vuh_vasr_VwVwR_rnd_sat | function | ||
| 2340 | core::core_arch::hexagon::v128 | Q6_Vuh_vasr_VwVwR_sat | function | ||
| 2341 | core::core_arch::hexagon::v128 | Q6_Vuh_vasr_WwVuh_rnd_sat | function | ||
| 2342 | core::core_arch::hexagon::v128 | Q6_Vuh_vasr_WwVuh_sat | function | ||
| 2343 | core::core_arch::hexagon::v128 | Q6_Vuh_vavg_VuhVuh | function | ||
| 2344 | core::core_arch::hexagon::v128 | Q6_Vuh_vavg_VuhVuh_rnd | function | ||
| 2345 | core::core_arch::hexagon::v128 | Q6_Vuh_vcl0_Vuh | function | ||
| 2346 | core::core_arch::hexagon::v128 | Q6_Vuh_vcvt_Vhf | function | ||
| 2347 | core::core_arch::hexagon::v128 | Q6_Vuh_vlsr_VuhR | function | ||
| 2348 | core::core_arch::hexagon::v128 | Q6_Vuh_vmax_VuhVuh | function | ||
| 2349 | core::core_arch::hexagon::v128 | Q6_Vuh_vmin_VuhVuh | function | ||
| 2350 | core::core_arch::hexagon::v128 | Q6_Vuh_vmpy_VuhVuh_rs16 | function | ||
| 2351 | core::core_arch::hexagon::v128 | Q6_Vuh_vpack_VwVw_sat | function | ||
| 2352 | core::core_arch::hexagon::v128 | Q6_Vuh_vround_VuwVuw_sat | function | ||
| 2353 | core::core_arch::hexagon::v128 | Q6_Vuh_vround_VwVw_sat | function | ||
| 2354 | core::core_arch::hexagon::v128 | Q6_Vuh_vsat_VuwVuw | function | ||
| 2355 | core::core_arch::hexagon::v128 | Q6_Vuh_vsub_VuhVuh_sat | function | ||
| 2356 | core::core_arch::hexagon::v128 | Q6_Vuw_vabsdiff_VwVw | function | ||
| 2357 | core::core_arch::hexagon::v128 | Q6_Vuw_vadd_VuwVuw_sat | function | ||
| 2358 | core::core_arch::hexagon::v128 | Q6_Vuw_vavg_VuwVuw | function | ||
| 2359 | core::core_arch::hexagon::v128 | Q6_Vuw_vavg_VuwVuw_rnd | function | ||
| 2360 | core::core_arch::hexagon::v128 | Q6_Vuw_vcl0_Vuw | function | ||
| 2361 | core::core_arch::hexagon::v128 | Q6_Vuw_vlsr_VuwR | function | ||
| 2362 | core::core_arch::hexagon::v128 | Q6_Vuw_vmpye_VuhRuh | function | ||
| 2363 | core::core_arch::hexagon::v128 | Q6_Vuw_vmpyeacc_VuwVuhRuh | function | ||
| 2364 | core::core_arch::hexagon::v128 | Q6_Vuw_vrmpy_VubRub | function | ||
| 2365 | core::core_arch::hexagon::v128 | Q6_Vuw_vrmpy_VubVub | function | ||
| 2366 | core::core_arch::hexagon::v128 | Q6_Vuw_vrmpyacc_VuwVubRub | function | ||
| 2367 | core::core_arch::hexagon::v128 | Q6_Vuw_vrmpyacc_VuwVubVub | function | ||
| 2368 | core::core_arch::hexagon::v128 | Q6_Vuw_vrotr_VuwVuw | function | ||
| 2369 | core::core_arch::hexagon::v128 | Q6_Vuw_vsub_VuwVuw_sat | function | ||
| 2370 | core::core_arch::hexagon::v128 | Q6_Vw_condacc_QVwVw | function | ||
| 2371 | core::core_arch::hexagon::v128 | Q6_Vw_condacc_QnVwVw | function | ||
| 2372 | core::core_arch::hexagon::v128 | Q6_Vw_condnac_QVwVw | function | ||
| 2373 | core::core_arch::hexagon::v128 | Q6_Vw_condnac_QnVwVw | function | ||
| 2374 | core::core_arch::hexagon::v128 | Q6_Vw_equals_Vsf | function | ||
| 2375 | core::core_arch::hexagon::v128 | Q6_Vw_prefixsum_Q | function | ||
| 2376 | core::core_arch::hexagon::v128 | Q6_Vw_vabs_Vw | function | ||
| 2377 | core::core_arch::hexagon::v128 | Q6_Vw_vabs_Vw_sat | function | ||
| 2378 | core::core_arch::hexagon::v128 | Q6_Vw_vadd_VwVw | function | ||
| 2379 | core::core_arch::hexagon::v128 | Q6_Vw_vadd_VwVwQ_carry_sat | function | ||
| 2380 | core::core_arch::hexagon::v128 | Q6_Vw_vadd_VwVw_sat | function | ||
| 2381 | core::core_arch::hexagon::v128 | Q6_Vw_vadd_vclb_VwVw | function | ||
| 2382 | core::core_arch::hexagon::v128 | Q6_Vw_vasl_VwR | function | ||
| 2383 | core::core_arch::hexagon::v128 | Q6_Vw_vasl_VwVw | function | ||
| 2384 | core::core_arch::hexagon::v128 | Q6_Vw_vaslacc_VwVwR | function | ||
| 2385 | core::core_arch::hexagon::v128 | Q6_Vw_vasr_VwR | function | ||
| 2386 | core::core_arch::hexagon::v128 | Q6_Vw_vasr_VwVw | function | ||
| 2387 | core::core_arch::hexagon::v128 | Q6_Vw_vasracc_VwVwR | function | ||
| 2388 | core::core_arch::hexagon::v128 | Q6_Vw_vavg_VwVw | function | ||
| 2389 | core::core_arch::hexagon::v128 | Q6_Vw_vavg_VwVw_rnd | function | ||
| 2390 | core::core_arch::hexagon::v128 | Q6_Vw_vdmpy_VhRb | function | ||
| 2391 | core::core_arch::hexagon::v128 | Q6_Vw_vdmpy_VhRh_sat | function | ||
| 2392 | core::core_arch::hexagon::v128 | Q6_Vw_vdmpy_VhRuh_sat | function | ||
| 2393 | core::core_arch::hexagon::v128 | Q6_Vw_vdmpy_VhVh_sat | function | ||
| 2394 | core::core_arch::hexagon::v128 | Q6_Vw_vdmpy_WhRh_sat | function | ||
| 2395 | core::core_arch::hexagon::v128 | Q6_Vw_vdmpy_WhRuh_sat | function | ||
| 2396 | core::core_arch::hexagon::v128 | Q6_Vw_vdmpyacc_VwVhRb | function | ||
| 2397 | core::core_arch::hexagon::v128 | Q6_Vw_vdmpyacc_VwVhRh_sat | function | ||
| 2398 | core::core_arch::hexagon::v128 | Q6_Vw_vdmpyacc_VwVhRuh_sat | function | ||
| 2399 | core::core_arch::hexagon::v128 | Q6_Vw_vdmpyacc_VwVhVh_sat | function | ||
| 2400 | core::core_arch::hexagon::v128 | Q6_Vw_vdmpyacc_VwWhRh_sat | function | ||
| 2401 | core::core_arch::hexagon::v128 | Q6_Vw_vdmpyacc_VwWhRuh_sat | function | ||
| 2402 | core::core_arch::hexagon::v128 | Q6_Vw_vfmv_Vw | function | ||
| 2403 | core::core_arch::hexagon::v128 | Q6_Vw_vinsert_VwR | function | ||
| 2404 | core::core_arch::hexagon::v128 | Q6_Vw_vlsr_VwVw | function | ||
| 2405 | core::core_arch::hexagon::v128 | Q6_Vw_vmax_VwVw | function | ||
| 2406 | core::core_arch::hexagon::v128 | Q6_Vw_vmin_VwVw | function | ||
| 2407 | core::core_arch::hexagon::v128 | Q6_Vw_vmpye_VwVuh | function | ||
| 2408 | core::core_arch::hexagon::v128 | Q6_Vw_vmpyi_VwRb | function | ||
| 2409 | core::core_arch::hexagon::v128 | Q6_Vw_vmpyi_VwRh | function | ||
| 2410 | core::core_arch::hexagon::v128 | Q6_Vw_vmpyi_VwRub | function | ||
| 2411 | core::core_arch::hexagon::v128 | Q6_Vw_vmpyiacc_VwVwRb | function | ||
| 2412 | core::core_arch::hexagon::v128 | Q6_Vw_vmpyiacc_VwVwRh | function | ||
| 2413 | core::core_arch::hexagon::v128 | Q6_Vw_vmpyiacc_VwVwRub | function | ||
| 2414 | core::core_arch::hexagon::v128 | Q6_Vw_vmpyie_VwVuh | function | ||
| 2415 | core::core_arch::hexagon::v128 | Q6_Vw_vmpyieacc_VwVwVh | function | ||
| 2416 | core::core_arch::hexagon::v128 | Q6_Vw_vmpyieacc_VwVwVuh | function | ||
| 2417 | core::core_arch::hexagon::v128 | Q6_Vw_vmpyieo_VhVh | function | ||
| 2418 | core::core_arch::hexagon::v128 | Q6_Vw_vmpyio_VwVh | function | ||
| 2419 | core::core_arch::hexagon::v128 | Q6_Vw_vmpyo_VwVh_s1_rnd_sat | function | ||
| 2420 | core::core_arch::hexagon::v128 | Q6_Vw_vmpyo_VwVh_s1_sat | function | ||
| 2421 | core::core_arch::hexagon::v128 | Q6_Vw_vmpyoacc_VwVwVh_s1_rnd_sat_shift | function | ||
| 2422 | core::core_arch::hexagon::v128 | Q6_Vw_vmpyoacc_VwVwVh_s1_sat_shift | function | ||
| 2423 | core::core_arch::hexagon::v128 | Q6_Vw_vnavg_VwVw | function | ||
| 2424 | core::core_arch::hexagon::v128 | Q6_Vw_vnormamt_Vw | function | ||
| 2425 | core::core_arch::hexagon::v128 | Q6_Vw_vrmpy_VbVb | function | ||
| 2426 | core::core_arch::hexagon::v128 | Q6_Vw_vrmpy_VubRb | function | ||
| 2427 | core::core_arch::hexagon::v128 | Q6_Vw_vrmpy_VubVb | function | ||
| 2428 | core::core_arch::hexagon::v128 | Q6_Vw_vrmpyacc_VwVbVb | function | ||
| 2429 | core::core_arch::hexagon::v128 | Q6_Vw_vrmpyacc_VwVubRb | function | ||
| 2430 | core::core_arch::hexagon::v128 | Q6_Vw_vrmpyacc_VwVubVb | function | ||
| 2431 | core::core_arch::hexagon::v128 | Q6_Vw_vsatdw_VwVw | function | ||
| 2432 | core::core_arch::hexagon::v128 | Q6_Vw_vsub_VwVw | function | ||
| 2433 | core::core_arch::hexagon::v128 | Q6_Vw_vsub_VwVw_sat | function | ||
| 2434 | core::core_arch::hexagon::v128 | Q6_W_equals_W | function | ||
| 2435 | core::core_arch::hexagon::v128 | Q6_W_vcombine_VV | function | ||
| 2436 | core::core_arch::hexagon::v128 | Q6_W_vdeal_VVR | function | ||
| 2437 | core::core_arch::hexagon::v128 | Q6_W_vmpye_VwVuh | function | ||
| 2438 | core::core_arch::hexagon::v128 | Q6_W_vmpyoacc_WVwVh | function | ||
| 2439 | core::core_arch::hexagon::v128 | Q6_W_vshuff_VVR | function | ||
| 2440 | core::core_arch::hexagon::v128 | Q6_W_vswap_QVV | function | ||
| 2441 | core::core_arch::hexagon::v128 | Q6_W_vzero | function | ||
| 2442 | core::core_arch::hexagon::v128 | Q6_Wb_vadd_WbWb | function | ||
| 2443 | core::core_arch::hexagon::v128 | Q6_Wb_vadd_WbWb_sat | function | ||
| 2444 | core::core_arch::hexagon::v128 | Q6_Wb_vshuffoe_VbVb | function | ||
| 2445 | core::core_arch::hexagon::v128 | Q6_Wb_vsub_WbWb | function | ||
| 2446 | core::core_arch::hexagon::v128 | Q6_Wb_vsub_WbWb_sat | function | ||
| 2447 | core::core_arch::hexagon::v128 | Q6_Wh_vadd_VubVub | function | ||
| 2448 | core::core_arch::hexagon::v128 | Q6_Wh_vadd_WhWh | function | ||
| 2449 | core::core_arch::hexagon::v128 | Q6_Wh_vadd_WhWh_sat | function | ||
| 2450 | core::core_arch::hexagon::v128 | Q6_Wh_vaddacc_WhVubVub | function | ||
| 2451 | core::core_arch::hexagon::v128 | Q6_Wh_vdmpy_WubRb | function | ||
| 2452 | core::core_arch::hexagon::v128 | Q6_Wh_vdmpyacc_WhWubRb | function | ||
| 2453 | core::core_arch::hexagon::v128 | Q6_Wh_vlut16_VbVhI | function | ||
| 2454 | core::core_arch::hexagon::v128 | Q6_Wh_vlut16_VbVhR | function | ||
| 2455 | core::core_arch::hexagon::v128 | Q6_Wh_vlut16_VbVhR_nomatch | function | ||
| 2456 | core::core_arch::hexagon::v128 | Q6_Wh_vlut16or_WhVbVhI | function | ||
| 2457 | core::core_arch::hexagon::v128 | Q6_Wh_vlut16or_WhVbVhR | function | ||
| 2458 | core::core_arch::hexagon::v128 | Q6_Wh_vmpa_WubRb | function | ||
| 2459 | core::core_arch::hexagon::v128 | Q6_Wh_vmpa_WubRub | function | ||
| 2460 | core::core_arch::hexagon::v128 | Q6_Wh_vmpa_WubWb | function | ||
| 2461 | core::core_arch::hexagon::v128 | Q6_Wh_vmpa_WubWub | function | ||
| 2462 | core::core_arch::hexagon::v128 | Q6_Wh_vmpaacc_WhWubRb | function | ||
| 2463 | core::core_arch::hexagon::v128 | Q6_Wh_vmpaacc_WhWubRub | function | ||
| 2464 | core::core_arch::hexagon::v128 | Q6_Wh_vmpy_VbVb | function | ||
| 2465 | core::core_arch::hexagon::v128 | Q6_Wh_vmpy_VubRb | function | ||
| 2466 | core::core_arch::hexagon::v128 | Q6_Wh_vmpy_VubVb | function | ||
| 2467 | core::core_arch::hexagon::v128 | Q6_Wh_vmpyacc_WhVbVb | function | ||
| 2468 | core::core_arch::hexagon::v128 | Q6_Wh_vmpyacc_WhVubRb | function | ||
| 2469 | core::core_arch::hexagon::v128 | Q6_Wh_vmpyacc_WhVubVb | function | ||
| 2470 | core::core_arch::hexagon::v128 | Q6_Wh_vshuffoe_VhVh | function | ||
| 2471 | core::core_arch::hexagon::v128 | Q6_Wh_vsub_VubVub | function | ||
| 2472 | core::core_arch::hexagon::v128 | Q6_Wh_vsub_WhWh | function | ||
| 2473 | core::core_arch::hexagon::v128 | Q6_Wh_vsub_WhWh_sat | function | ||
| 2474 | core::core_arch::hexagon::v128 | Q6_Wh_vsxt_Vb | function | ||
| 2475 | core::core_arch::hexagon::v128 | Q6_Wh_vtmpy_WbRb | function | ||
| 2476 | core::core_arch::hexagon::v128 | Q6_Wh_vtmpy_WubRb | function | ||
| 2477 | core::core_arch::hexagon::v128 | Q6_Wh_vtmpyacc_WhWbRb | function | ||
| 2478 | core::core_arch::hexagon::v128 | Q6_Wh_vtmpyacc_WhWubRb | function | ||
| 2479 | core::core_arch::hexagon::v128 | Q6_Wh_vunpack_Vb | function | ||
| 2480 | core::core_arch::hexagon::v128 | Q6_Wh_vunpackoor_WhVb | function | ||
| 2481 | core::core_arch::hexagon::v128 | Q6_Whf_vcvt2_Vb | function | ||
| 2482 | core::core_arch::hexagon::v128 | Q6_Whf_vcvt2_Vub | function | ||
| 2483 | core::core_arch::hexagon::v128 | Q6_Whf_vcvt_V | function | ||
| 2484 | core::core_arch::hexagon::v128 | Q6_Whf_vcvt_Vb | function | ||
| 2485 | core::core_arch::hexagon::v128 | Q6_Whf_vcvt_Vub | function | ||
| 2486 | core::core_arch::hexagon::v128 | Q6_Wqf32_vmpy_VhfVhf | function | ||
| 2487 | core::core_arch::hexagon::v128 | Q6_Wqf32_vmpy_Vqf16Vhf | function | ||
| 2488 | core::core_arch::hexagon::v128 | Q6_Wqf32_vmpy_Vqf16Vqf16 | function | ||
| 2489 | core::core_arch::hexagon::v128 | Q6_Wsf_vadd_VhfVhf | function | ||
| 2490 | core::core_arch::hexagon::v128 | Q6_Wsf_vcvt_Vhf | function | ||
| 2491 | core::core_arch::hexagon::v128 | Q6_Wsf_vmpy_VhfVhf | function | ||
| 2492 | core::core_arch::hexagon::v128 | Q6_Wsf_vmpyacc_WsfVhfVhf | function | ||
| 2493 | core::core_arch::hexagon::v128 | Q6_Wsf_vsub_VhfVhf | function | ||
| 2494 | core::core_arch::hexagon::v128 | Q6_Wub_vadd_WubWub_sat | function | ||
| 2495 | core::core_arch::hexagon::v128 | Q6_Wub_vsub_WubWub_sat | function | ||
| 2496 | core::core_arch::hexagon::v128 | Q6_Wuh_vadd_WuhWuh_sat | function | ||
| 2497 | core::core_arch::hexagon::v128 | Q6_Wuh_vmpy_VubRub | function | ||
| 2498 | core::core_arch::hexagon::v128 | Q6_Wuh_vmpy_VubVub | function | ||
| 2499 | core::core_arch::hexagon::v128 | Q6_Wuh_vmpyacc_WuhVubRub | function | ||
| 2500 | core::core_arch::hexagon::v128 | Q6_Wuh_vmpyacc_WuhVubVub | function | ||
| 2501 | core::core_arch::hexagon::v128 | Q6_Wuh_vsub_WuhWuh_sat | function | ||
| 2502 | core::core_arch::hexagon::v128 | Q6_Wuh_vunpack_Vub | function | ||
| 2503 | core::core_arch::hexagon::v128 | Q6_Wuh_vzxt_Vub | function | ||
| 2504 | core::core_arch::hexagon::v128 | Q6_Wuw_vadd_WuwWuw_sat | function | ||
| 2505 | core::core_arch::hexagon::v128 | Q6_Wuw_vdsad_WuhRuh | function | ||
| 2506 | core::core_arch::hexagon::v128 | Q6_Wuw_vdsadacc_WuwWuhRuh | function | ||
| 2507 | core::core_arch::hexagon::v128 | Q6_Wuw_vmpy_VuhRuh | function | ||
| 2508 | core::core_arch::hexagon::v128 | Q6_Wuw_vmpy_VuhVuh | function | ||
| 2509 | core::core_arch::hexagon::v128 | Q6_Wuw_vmpyacc_WuwVuhRuh | function | ||
| 2510 | core::core_arch::hexagon::v128 | Q6_Wuw_vmpyacc_WuwVuhVuh | function | ||
| 2511 | core::core_arch::hexagon::v128 | Q6_Wuw_vrmpy_WubRubI | function | ||
| 2512 | core::core_arch::hexagon::v128 | Q6_Wuw_vrmpyacc_WuwWubRubI | function | ||
| 2513 | core::core_arch::hexagon::v128 | Q6_Wuw_vrsad_WubRubI | function | ||
| 2514 | core::core_arch::hexagon::v128 | Q6_Wuw_vrsadacc_WuwWubRubI | function | ||
| 2515 | core::core_arch::hexagon::v128 | Q6_Wuw_vsub_WuwWuw_sat | function | ||
| 2516 | core::core_arch::hexagon::v128 | Q6_Wuw_vunpack_Vuh | function | ||
| 2517 | core::core_arch::hexagon::v128 | Q6_Wuw_vzxt_Vuh | function | ||
| 2518 | core::core_arch::hexagon::v128 | Q6_Ww_v6mpy_WubWbI_h | function | ||
| 2519 | core::core_arch::hexagon::v128 | Q6_Ww_v6mpy_WubWbI_v | function | ||
| 2520 | core::core_arch::hexagon::v128 | Q6_Ww_v6mpyacc_WwWubWbI_h | function | ||
| 2521 | core::core_arch::hexagon::v128 | Q6_Ww_v6mpyacc_WwWubWbI_v | function | ||
| 2522 | core::core_arch::hexagon::v128 | Q6_Ww_vadd_VhVh | function | ||
| 2523 | core::core_arch::hexagon::v128 | Q6_Ww_vadd_VuhVuh | function | ||
| 2524 | core::core_arch::hexagon::v128 | Q6_Ww_vadd_WwWw | function | ||
| 2525 | core::core_arch::hexagon::v128 | Q6_Ww_vadd_WwWw_sat | function | ||
| 2526 | core::core_arch::hexagon::v128 | Q6_Ww_vaddacc_WwVhVh | function | ||
| 2527 | core::core_arch::hexagon::v128 | Q6_Ww_vaddacc_WwVuhVuh | function | ||
| 2528 | core::core_arch::hexagon::v128 | Q6_Ww_vasrinto_WwVwVw | function | ||
| 2529 | core::core_arch::hexagon::v128 | Q6_Ww_vdmpy_WhRb | function | ||
| 2530 | core::core_arch::hexagon::v128 | Q6_Ww_vdmpyacc_WwWhRb | function | ||
| 2531 | core::core_arch::hexagon::v128 | Q6_Ww_vmpa_WhRb | function | ||
| 2532 | core::core_arch::hexagon::v128 | Q6_Ww_vmpa_WuhRb | function | ||
| 2533 | core::core_arch::hexagon::v128 | Q6_Ww_vmpaacc_WwWhRb | function | ||
| 2534 | core::core_arch::hexagon::v128 | Q6_Ww_vmpaacc_WwWuhRb | function | ||
| 2535 | core::core_arch::hexagon::v128 | Q6_Ww_vmpy_VhRh | function | ||
| 2536 | core::core_arch::hexagon::v128 | Q6_Ww_vmpy_VhVh | function | ||
| 2537 | core::core_arch::hexagon::v128 | Q6_Ww_vmpy_VhVuh | function | ||
| 2538 | core::core_arch::hexagon::v128 | Q6_Ww_vmpyacc_WwVhRh | function | ||
| 2539 | core::core_arch::hexagon::v128 | Q6_Ww_vmpyacc_WwVhRh_sat | function | ||
| 2540 | core::core_arch::hexagon::v128 | Q6_Ww_vmpyacc_WwVhVh | function | ||
| 2541 | core::core_arch::hexagon::v128 | Q6_Ww_vmpyacc_WwVhVuh | function | ||
| 2542 | core::core_arch::hexagon::v128 | Q6_Ww_vrmpy_WubRbI | function | ||
| 2543 | core::core_arch::hexagon::v128 | Q6_Ww_vrmpyacc_WwWubRbI | function | ||
| 2544 | core::core_arch::hexagon::v128 | Q6_Ww_vsub_VhVh | function | ||
| 2545 | core::core_arch::hexagon::v128 | Q6_Ww_vsub_VuhVuh | function | ||
| 2546 | core::core_arch::hexagon::v128 | Q6_Ww_vsub_WwWw | function | ||
| 2547 | core::core_arch::hexagon::v128 | Q6_Ww_vsub_WwWw_sat | function | ||
| 2548 | core::core_arch::hexagon::v128 | Q6_Ww_vsxt_Vh | function | ||
| 2549 | core::core_arch::hexagon::v128 | Q6_Ww_vtmpy_WhRb | function | ||
| 2550 | core::core_arch::hexagon::v128 | Q6_Ww_vtmpyacc_WwWhRb | function | ||
| 2551 | core::core_arch::hexagon::v128 | Q6_Ww_vunpack_Vh | function | ||
| 2552 | core::core_arch::hexagon::v128 | Q6_Ww_vunpackoor_WwVh | function | ||
| 2553 | core::core_arch::hexagon::v128 | Q6_vgather_AQRMVh | function | ||
| 2554 | core::core_arch::hexagon::v128 | Q6_vgather_AQRMVw | function | ||
| 2555 | core::core_arch::hexagon::v128 | Q6_vgather_AQRMWw | function | ||
| 2556 | core::core_arch::hexagon::v128 | Q6_vgather_ARMVh | function | ||
| 2557 | core::core_arch::hexagon::v128 | Q6_vgather_ARMVw | function | ||
| 2558 | core::core_arch::hexagon::v128 | Q6_vgather_ARMWw | function | ||
| 2559 | core::core_arch::hexagon::v128 | Q6_vmem_QRIV | function | ||
| 2560 | core::core_arch::hexagon::v128 | Q6_vmem_QRIV_nt | function | ||
| 2561 | core::core_arch::hexagon::v128 | Q6_vmem_QnRIV | function | ||
| 2562 | core::core_arch::hexagon::v128 | Q6_vmem_QnRIV_nt | function | ||
| 2563 | core::core_arch::hexagon::v128 | Q6_vscatter_QRMVhV | function | ||
| 2564 | core::core_arch::hexagon::v128 | Q6_vscatter_QRMVwV | function | ||
| 2565 | core::core_arch::hexagon::v128 | Q6_vscatter_QRMWwV | function | ||
| 2566 | core::core_arch::hexagon::v128 | Q6_vscatter_RMVhV | function | ||
| 2567 | core::core_arch::hexagon::v128 | Q6_vscatter_RMVwV | function | ||
| 2568 | core::core_arch::hexagon::v128 | Q6_vscatter_RMWwV | function | ||
| 2569 | core::core_arch::hexagon::v128 | Q6_vscatteracc_RMVhV | function | ||
| 2570 | core::core_arch::hexagon::v128 | Q6_vscatteracc_RMVwV | function | ||
| 2571 | core::core_arch::hexagon::v128 | Q6_vscatteracc_RMWwV | function | ||
| 2572 | core::core_arch::hexagon::v64 | Q6_Q_and_QQ | function | ||
| 2573 | core::core_arch::hexagon::v64 | Q6_Q_and_QQn | function | ||
| 2574 | core::core_arch::hexagon::v64 | Q6_Q_not_Q | function | ||
| 2575 | core::core_arch::hexagon::v64 | Q6_Q_or_QQ | function | ||
| 2576 | core::core_arch::hexagon::v64 | Q6_Q_or_QQn | function | ||
| 2577 | core::core_arch::hexagon::v64 | Q6_Q_vand_VR | function | ||
| 2578 | core::core_arch::hexagon::v64 | Q6_Q_vandor_QVR | function | ||
| 2579 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_eq_VbVb | function | ||
| 2580 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_eq_VhVh | function | ||
| 2581 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_eq_VwVw | function | ||
| 2582 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_eqand_QVbVb | function | ||
| 2583 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_eqand_QVhVh | function | ||
| 2584 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_eqand_QVwVw | function | ||
| 2585 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_eqor_QVbVb | function | ||
| 2586 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_eqor_QVhVh | function | ||
| 2587 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_eqor_QVwVw | function | ||
| 2588 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_eqxacc_QVbVb | function | ||
| 2589 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_eqxacc_QVhVh | function | ||
| 2590 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_eqxacc_QVwVw | function | ||
| 2591 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gt_VbVb | function | ||
| 2592 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gt_VhVh | function | ||
| 2593 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gt_VhfVhf | function | ||
| 2594 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gt_VsfVsf | function | ||
| 2595 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gt_VubVub | function | ||
| 2596 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gt_VuhVuh | function | ||
| 2597 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gt_VuwVuw | function | ||
| 2598 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gt_VwVw | function | ||
| 2599 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtand_QVbVb | function | ||
| 2600 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtand_QVhVh | function | ||
| 2601 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtand_QVhfVhf | function | ||
| 2602 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtand_QVsfVsf | function | ||
| 2603 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtand_QVubVub | function | ||
| 2604 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtand_QVuhVuh | function | ||
| 2605 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtand_QVuwVuw | function | ||
| 2606 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtand_QVwVw | function | ||
| 2607 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtor_QVbVb | function | ||
| 2608 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtor_QVhVh | function | ||
| 2609 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtor_QVhfVhf | function | ||
| 2610 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtor_QVsfVsf | function | ||
| 2611 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtor_QVubVub | function | ||
| 2612 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtor_QVuhVuh | function | ||
| 2613 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtor_QVuwVuw | function | ||
| 2614 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtor_QVwVw | function | ||
| 2615 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtxacc_QVbVb | function | ||
| 2616 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtxacc_QVhVh | function | ||
| 2617 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtxacc_QVhfVhf | function | ||
| 2618 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtxacc_QVsfVsf | function | ||
| 2619 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtxacc_QVubVub | function | ||
| 2620 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtxacc_QVuhVuh | function | ||
| 2621 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtxacc_QVuwVuw | function | ||
| 2622 | core::core_arch::hexagon::v64 | Q6_Q_vcmp_gtxacc_QVwVw | function | ||
| 2623 | core::core_arch::hexagon::v64 | Q6_Q_vsetq2_R | function | ||
| 2624 | core::core_arch::hexagon::v64 | Q6_Q_vsetq_R | function | ||
| 2625 | core::core_arch::hexagon::v64 | Q6_Q_xor_QQ | function | ||
| 2626 | core::core_arch::hexagon::v64 | Q6_Qb_vshuffe_QhQh | function | ||
| 2627 | core::core_arch::hexagon::v64 | Q6_Qh_vshuffe_QwQw | function | ||
| 2628 | core::core_arch::hexagon::v64 | Q6_R_vextract_VR | function | ||
| 2629 | core::core_arch::hexagon::v64 | Q6_V_equals_V | function | ||
| 2630 | core::core_arch::hexagon::v64 | Q6_V_hi_W | function | ||
| 2631 | core::core_arch::hexagon::v64 | Q6_V_lo_W | function | ||
| 2632 | core::core_arch::hexagon::v64 | Q6_V_vabs_V | function | ||
| 2633 | core::core_arch::hexagon::v64 | Q6_V_valign_VVI | function | ||
| 2634 | core::core_arch::hexagon::v64 | Q6_V_valign_VVR | function | ||
| 2635 | core::core_arch::hexagon::v64 | Q6_V_vand_QR | function | ||
| 2636 | core::core_arch::hexagon::v64 | Q6_V_vand_QV | function | ||
| 2637 | core::core_arch::hexagon::v64 | Q6_V_vand_QnR | function | ||
| 2638 | core::core_arch::hexagon::v64 | Q6_V_vand_QnV | function | ||
| 2639 | core::core_arch::hexagon::v64 | Q6_V_vand_VV | function | ||
| 2640 | core::core_arch::hexagon::v64 | Q6_V_vandor_VQR | function | ||
| 2641 | core::core_arch::hexagon::v64 | Q6_V_vandor_VQnR | function | ||
| 2642 | core::core_arch::hexagon::v64 | Q6_V_vdelta_VV | function | ||
| 2643 | core::core_arch::hexagon::v64 | Q6_V_vfmax_VV | function | ||
| 2644 | core::core_arch::hexagon::v64 | Q6_V_vfmin_VV | function | ||
| 2645 | core::core_arch::hexagon::v64 | Q6_V_vfneg_V | function | ||
| 2646 | core::core_arch::hexagon::v64 | Q6_V_vgetqfext_VR | function | ||
| 2647 | core::core_arch::hexagon::v64 | Q6_V_vlalign_VVI | function | ||
| 2648 | core::core_arch::hexagon::v64 | Q6_V_vlalign_VVR | function | ||
| 2649 | core::core_arch::hexagon::v64 | Q6_V_vmux_QVV | function | ||
| 2650 | core::core_arch::hexagon::v64 | Q6_V_vnot_V | function | ||
| 2651 | core::core_arch::hexagon::v64 | Q6_V_vor_VV | function | ||
| 2652 | core::core_arch::hexagon::v64 | Q6_V_vrdelta_VV | function | ||
| 2653 | core::core_arch::hexagon::v64 | Q6_V_vror_VR | function | ||
| 2654 | core::core_arch::hexagon::v64 | Q6_V_vsetqfext_VR | function | ||
| 2655 | core::core_arch::hexagon::v64 | Q6_V_vsplat_R | function | ||
| 2656 | core::core_arch::hexagon::v64 | Q6_V_vxor_VV | function | ||
| 2657 | core::core_arch::hexagon::v64 | Q6_V_vzero | function | ||
| 2658 | core::core_arch::hexagon::v64 | Q6_Vb_condacc_QVbVb | function | ||
| 2659 | core::core_arch::hexagon::v64 | Q6_Vb_condacc_QnVbVb | function | ||
| 2660 | core::core_arch::hexagon::v64 | Q6_Vb_condnac_QVbVb | function | ||
| 2661 | core::core_arch::hexagon::v64 | Q6_Vb_condnac_QnVbVb | function | ||
| 2662 | core::core_arch::hexagon::v64 | Q6_Vb_prefixsum_Q | function | ||
| 2663 | core::core_arch::hexagon::v64 | Q6_Vb_vabs_Vb | function | ||
| 2664 | core::core_arch::hexagon::v64 | Q6_Vb_vabs_Vb_sat | function | ||
| 2665 | core::core_arch::hexagon::v64 | Q6_Vb_vadd_VbVb | function | ||
| 2666 | core::core_arch::hexagon::v64 | Q6_Vb_vadd_VbVb_sat | function | ||
| 2667 | core::core_arch::hexagon::v64 | Q6_Vb_vasr_VhVhR_rnd_sat | function | ||
| 2668 | core::core_arch::hexagon::v64 | Q6_Vb_vasr_VhVhR_sat | function | ||
| 2669 | core::core_arch::hexagon::v64 | Q6_Vb_vavg_VbVb | function | ||
| 2670 | core::core_arch::hexagon::v64 | Q6_Vb_vavg_VbVb_rnd | function | ||
| 2671 | core::core_arch::hexagon::v64 | Q6_Vb_vcvt_VhfVhf | function | ||
| 2672 | core::core_arch::hexagon::v64 | Q6_Vb_vdeal_Vb | function | ||
| 2673 | core::core_arch::hexagon::v64 | Q6_Vb_vdeale_VbVb | function | ||
| 2674 | core::core_arch::hexagon::v64 | Q6_Vb_vlut32_VbVbI | function | ||
| 2675 | core::core_arch::hexagon::v64 | Q6_Vb_vlut32_VbVbR | function | ||
| 2676 | core::core_arch::hexagon::v64 | Q6_Vb_vlut32_VbVbR_nomatch | function | ||
| 2677 | core::core_arch::hexagon::v64 | Q6_Vb_vlut32or_VbVbVbI | function | ||
| 2678 | core::core_arch::hexagon::v64 | Q6_Vb_vlut32or_VbVbVbR | function | ||
| 2679 | core::core_arch::hexagon::v64 | Q6_Vb_vmax_VbVb | function | ||
| 2680 | core::core_arch::hexagon::v64 | Q6_Vb_vmin_VbVb | function | ||
| 2681 | core::core_arch::hexagon::v64 | Q6_Vb_vnavg_VbVb | function | ||
| 2682 | core::core_arch::hexagon::v64 | Q6_Vb_vnavg_VubVub | function | ||
| 2683 | core::core_arch::hexagon::v64 | Q6_Vb_vpack_VhVh_sat | function | ||
| 2684 | core::core_arch::hexagon::v64 | Q6_Vb_vpacke_VhVh | function | ||
| 2685 | core::core_arch::hexagon::v64 | Q6_Vb_vpacko_VhVh | function | ||
| 2686 | core::core_arch::hexagon::v64 | Q6_Vb_vround_VhVh_sat | function | ||
| 2687 | core::core_arch::hexagon::v64 | Q6_Vb_vshuff_Vb | function | ||
| 2688 | core::core_arch::hexagon::v64 | Q6_Vb_vshuffe_VbVb | function | ||
| 2689 | core::core_arch::hexagon::v64 | Q6_Vb_vshuffo_VbVb | function | ||
| 2690 | core::core_arch::hexagon::v64 | Q6_Vb_vsplat_R | function | ||
| 2691 | core::core_arch::hexagon::v64 | Q6_Vb_vsub_VbVb | function | ||
| 2692 | core::core_arch::hexagon::v64 | Q6_Vb_vsub_VbVb_sat | function | ||
| 2693 | core::core_arch::hexagon::v64 | Q6_Vh_condacc_QVhVh | function | ||
| 2694 | core::core_arch::hexagon::v64 | Q6_Vh_condacc_QnVhVh | function | ||
| 2695 | core::core_arch::hexagon::v64 | Q6_Vh_condnac_QVhVh | function | ||
| 2696 | core::core_arch::hexagon::v64 | Q6_Vh_condnac_QnVhVh | function | ||
| 2697 | core::core_arch::hexagon::v64 | Q6_Vh_equals_Vhf | function | ||
| 2698 | core::core_arch::hexagon::v64 | Q6_Vh_prefixsum_Q | function | ||
| 2699 | core::core_arch::hexagon::v64 | Q6_Vh_vabs_Vh | function | ||
| 2700 | core::core_arch::hexagon::v64 | Q6_Vh_vabs_Vh_sat | function | ||
| 2701 | core::core_arch::hexagon::v64 | Q6_Vh_vadd_VhVh | function | ||
| 2702 | core::core_arch::hexagon::v64 | Q6_Vh_vadd_VhVh_sat | function | ||
| 2703 | core::core_arch::hexagon::v64 | Q6_Vh_vadd_vclb_VhVh | function | ||
| 2704 | core::core_arch::hexagon::v64 | Q6_Vh_vasl_VhR | function | ||
| 2705 | core::core_arch::hexagon::v64 | Q6_Vh_vasl_VhVh | function | ||
| 2706 | core::core_arch::hexagon::v64 | Q6_Vh_vaslacc_VhVhR | function | ||
| 2707 | core::core_arch::hexagon::v64 | Q6_Vh_vasr_VhR | function | ||
| 2708 | core::core_arch::hexagon::v64 | Q6_Vh_vasr_VhVh | function | ||
| 2709 | core::core_arch::hexagon::v64 | Q6_Vh_vasr_VwVwR | function | ||
| 2710 | core::core_arch::hexagon::v64 | Q6_Vh_vasr_VwVwR_rnd_sat | function | ||
| 2711 | core::core_arch::hexagon::v64 | Q6_Vh_vasr_VwVwR_sat | function | ||
| 2712 | core::core_arch::hexagon::v64 | Q6_Vh_vasracc_VhVhR | function | ||
| 2713 | core::core_arch::hexagon::v64 | Q6_Vh_vavg_VhVh | function | ||
| 2714 | core::core_arch::hexagon::v64 | Q6_Vh_vavg_VhVh_rnd | function | ||
| 2715 | core::core_arch::hexagon::v64 | Q6_Vh_vcvt_Vhf | function | ||
| 2716 | core::core_arch::hexagon::v64 | Q6_Vh_vdeal_Vh | function | ||
| 2717 | core::core_arch::hexagon::v64 | Q6_Vh_vdmpy_VubRb | function | ||
| 2718 | core::core_arch::hexagon::v64 | Q6_Vh_vdmpyacc_VhVubRb | function | ||
| 2719 | core::core_arch::hexagon::v64 | Q6_Vh_vlsr_VhVh | function | ||
| 2720 | core::core_arch::hexagon::v64 | Q6_Vh_vmax_VhVh | function | ||
| 2721 | core::core_arch::hexagon::v64 | Q6_Vh_vmin_VhVh | function | ||
| 2722 | core::core_arch::hexagon::v64 | Q6_Vh_vmpy_VhRh_s1_rnd_sat | function | ||
| 2723 | core::core_arch::hexagon::v64 | Q6_Vh_vmpy_VhRh_s1_sat | function | ||
| 2724 | core::core_arch::hexagon::v64 | Q6_Vh_vmpy_VhVh_s1_rnd_sat | function | ||
| 2725 | core::core_arch::hexagon::v64 | Q6_Vh_vmpyi_VhRb | function | ||
| 2726 | core::core_arch::hexagon::v64 | Q6_Vh_vmpyi_VhVh | function | ||
| 2727 | core::core_arch::hexagon::v64 | Q6_Vh_vmpyiacc_VhVhRb | function | ||
| 2728 | core::core_arch::hexagon::v64 | Q6_Vh_vmpyiacc_VhVhVh | function | ||
| 2729 | core::core_arch::hexagon::v64 | Q6_Vh_vnavg_VhVh | function | ||
| 2730 | core::core_arch::hexagon::v64 | Q6_Vh_vnormamt_Vh | function | ||
| 2731 | core::core_arch::hexagon::v64 | Q6_Vh_vpack_VwVw_sat | function | ||
| 2732 | core::core_arch::hexagon::v64 | Q6_Vh_vpacke_VwVw | function | ||
| 2733 | core::core_arch::hexagon::v64 | Q6_Vh_vpacko_VwVw | function | ||
| 2734 | core::core_arch::hexagon::v64 | Q6_Vh_vpopcount_Vh | function | ||
| 2735 | core::core_arch::hexagon::v64 | Q6_Vh_vround_VwVw_sat | function | ||
| 2736 | core::core_arch::hexagon::v64 | Q6_Vh_vsat_VwVw | function | ||
| 2737 | core::core_arch::hexagon::v64 | Q6_Vh_vshuff_Vh | function | ||
| 2738 | core::core_arch::hexagon::v64 | Q6_Vh_vshuffe_VhVh | function | ||
| 2739 | core::core_arch::hexagon::v64 | Q6_Vh_vshuffo_VhVh | function | ||
| 2740 | core::core_arch::hexagon::v64 | Q6_Vh_vsplat_R | function | ||
| 2741 | core::core_arch::hexagon::v64 | Q6_Vh_vsub_VhVh | function | ||
| 2742 | core::core_arch::hexagon::v64 | Q6_Vh_vsub_VhVh_sat | function | ||
| 2743 | core::core_arch::hexagon::v64 | Q6_Vhf_equals_Vh | function | ||
| 2744 | core::core_arch::hexagon::v64 | Q6_Vhf_equals_Vqf16 | function | ||
| 2745 | core::core_arch::hexagon::v64 | Q6_Vhf_equals_Wqf32 | function | ||
| 2746 | core::core_arch::hexagon::v64 | Q6_Vhf_vabs_Vhf | function | ||
| 2747 | core::core_arch::hexagon::v64 | Q6_Vhf_vadd_VhfVhf | function | ||
| 2748 | core::core_arch::hexagon::v64 | Q6_Vhf_vcvt_Vh | function | ||
| 2749 | core::core_arch::hexagon::v64 | Q6_Vhf_vcvt_VsfVsf | function | ||
| 2750 | core::core_arch::hexagon::v64 | Q6_Vhf_vcvt_Vuh | function | ||
| 2751 | core::core_arch::hexagon::v64 | Q6_Vhf_vfmax_VhfVhf | function | ||
| 2752 | core::core_arch::hexagon::v64 | Q6_Vhf_vfmin_VhfVhf | function | ||
| 2753 | core::core_arch::hexagon::v64 | Q6_Vhf_vfneg_Vhf | function | ||
| 2754 | core::core_arch::hexagon::v64 | Q6_Vhf_vmax_VhfVhf | function | ||
| 2755 | core::core_arch::hexagon::v64 | Q6_Vhf_vmin_VhfVhf | function | ||
| 2756 | core::core_arch::hexagon::v64 | Q6_Vhf_vmpy_VhfVhf | function | ||
| 2757 | core::core_arch::hexagon::v64 | Q6_Vhf_vmpyacc_VhfVhfVhf | function | ||
| 2758 | core::core_arch::hexagon::v64 | Q6_Vhf_vsub_VhfVhf | function | ||
| 2759 | core::core_arch::hexagon::v64 | Q6_Vqf16_vadd_VhfVhf | function | ||
| 2760 | core::core_arch::hexagon::v64 | Q6_Vqf16_vadd_Vqf16Vhf | function | ||
| 2761 | core::core_arch::hexagon::v64 | Q6_Vqf16_vadd_Vqf16Vqf16 | function | ||
| 2762 | core::core_arch::hexagon::v64 | Q6_Vqf16_vmpy_VhfVhf | function | ||
| 2763 | core::core_arch::hexagon::v64 | Q6_Vqf16_vmpy_Vqf16Vhf | function | ||
| 2764 | core::core_arch::hexagon::v64 | Q6_Vqf16_vmpy_Vqf16Vqf16 | function | ||
| 2765 | core::core_arch::hexagon::v64 | Q6_Vqf16_vsub_VhfVhf | function | ||
| 2766 | core::core_arch::hexagon::v64 | Q6_Vqf16_vsub_Vqf16Vhf | function | ||
| 2767 | core::core_arch::hexagon::v64 | Q6_Vqf16_vsub_Vqf16Vqf16 | function | ||
| 2768 | core::core_arch::hexagon::v64 | Q6_Vqf32_vadd_Vqf32Vqf32 | function | ||
| 2769 | core::core_arch::hexagon::v64 | Q6_Vqf32_vadd_Vqf32Vsf | function | ||
| 2770 | core::core_arch::hexagon::v64 | Q6_Vqf32_vadd_VsfVsf | function | ||
| 2771 | core::core_arch::hexagon::v64 | Q6_Vqf32_vmpy_Vqf32Vqf32 | function | ||
| 2772 | core::core_arch::hexagon::v64 | Q6_Vqf32_vmpy_VsfVsf | function | ||
| 2773 | core::core_arch::hexagon::v64 | Q6_Vqf32_vsub_Vqf32Vqf32 | function | ||
| 2774 | core::core_arch::hexagon::v64 | Q6_Vqf32_vsub_Vqf32Vsf | function | ||
| 2775 | core::core_arch::hexagon::v64 | Q6_Vqf32_vsub_VsfVsf | function | ||
| 2776 | core::core_arch::hexagon::v64 | Q6_Vsf_equals_Vqf32 | function | ||
| 2777 | core::core_arch::hexagon::v64 | Q6_Vsf_equals_Vw | function | ||
| 2778 | core::core_arch::hexagon::v64 | Q6_Vsf_vabs_Vsf | function | ||
| 2779 | core::core_arch::hexagon::v64 | Q6_Vsf_vadd_VsfVsf | function | ||
| 2780 | core::core_arch::hexagon::v64 | Q6_Vsf_vdmpy_VhfVhf | function | ||
| 2781 | core::core_arch::hexagon::v64 | Q6_Vsf_vdmpyacc_VsfVhfVhf | function | ||
| 2782 | core::core_arch::hexagon::v64 | Q6_Vsf_vfmax_VsfVsf | function | ||
| 2783 | core::core_arch::hexagon::v64 | Q6_Vsf_vfmin_VsfVsf | function | ||
| 2784 | core::core_arch::hexagon::v64 | Q6_Vsf_vfneg_Vsf | function | ||
| 2785 | core::core_arch::hexagon::v64 | Q6_Vsf_vmax_VsfVsf | function | ||
| 2786 | core::core_arch::hexagon::v64 | Q6_Vsf_vmin_VsfVsf | function | ||
| 2787 | core::core_arch::hexagon::v64 | Q6_Vsf_vmpy_VsfVsf | function | ||
| 2788 | core::core_arch::hexagon::v64 | Q6_Vsf_vsub_VsfVsf | function | ||
| 2789 | core::core_arch::hexagon::v64 | Q6_Vub_vabsdiff_VubVub | function | ||
| 2790 | core::core_arch::hexagon::v64 | Q6_Vub_vadd_VubVb_sat | function | ||
| 2791 | core::core_arch::hexagon::v64 | Q6_Vub_vadd_VubVub_sat | function | ||
| 2792 | core::core_arch::hexagon::v64 | Q6_Vub_vasr_VhVhR_rnd_sat | function | ||
| 2793 | core::core_arch::hexagon::v64 | Q6_Vub_vasr_VhVhR_sat | function | ||
| 2794 | core::core_arch::hexagon::v64 | Q6_Vub_vasr_VuhVuhR_rnd_sat | function | ||
| 2795 | core::core_arch::hexagon::v64 | Q6_Vub_vasr_VuhVuhR_sat | function | ||
| 2796 | core::core_arch::hexagon::v64 | Q6_Vub_vasr_WuhVub_rnd_sat | function | ||
| 2797 | core::core_arch::hexagon::v64 | Q6_Vub_vasr_WuhVub_sat | function | ||
| 2798 | core::core_arch::hexagon::v64 | Q6_Vub_vavg_VubVub | function | ||
| 2799 | core::core_arch::hexagon::v64 | Q6_Vub_vavg_VubVub_rnd | function | ||
| 2800 | core::core_arch::hexagon::v64 | Q6_Vub_vcvt_VhfVhf | function | ||
| 2801 | core::core_arch::hexagon::v64 | Q6_Vub_vlsr_VubR | function | ||
| 2802 | core::core_arch::hexagon::v64 | Q6_Vub_vmax_VubVub | function | ||
| 2803 | core::core_arch::hexagon::v64 | Q6_Vub_vmin_VubVub | function | ||
| 2804 | core::core_arch::hexagon::v64 | Q6_Vub_vpack_VhVh_sat | function | ||
| 2805 | core::core_arch::hexagon::v64 | Q6_Vub_vround_VhVh_sat | function | ||
| 2806 | core::core_arch::hexagon::v64 | Q6_Vub_vround_VuhVuh_sat | function | ||
| 2807 | core::core_arch::hexagon::v64 | Q6_Vub_vsat_VhVh | function | ||
| 2808 | core::core_arch::hexagon::v64 | Q6_Vub_vsub_VubVb_sat | function | ||
| 2809 | core::core_arch::hexagon::v64 | Q6_Vub_vsub_VubVub_sat | function | ||
| 2810 | core::core_arch::hexagon::v64 | Q6_Vuh_vabsdiff_VhVh | function | ||
| 2811 | core::core_arch::hexagon::v64 | Q6_Vuh_vabsdiff_VuhVuh | function | ||
| 2812 | core::core_arch::hexagon::v64 | Q6_Vuh_vadd_VuhVuh_sat | function | ||
| 2813 | core::core_arch::hexagon::v64 | Q6_Vuh_vasr_VuwVuwR_rnd_sat | function | ||
| 2814 | core::core_arch::hexagon::v64 | Q6_Vuh_vasr_VuwVuwR_sat | function | ||
| 2815 | core::core_arch::hexagon::v64 | Q6_Vuh_vasr_VwVwR_rnd_sat | function | ||
| 2816 | core::core_arch::hexagon::v64 | Q6_Vuh_vasr_VwVwR_sat | function | ||
| 2817 | core::core_arch::hexagon::v64 | Q6_Vuh_vasr_WwVuh_rnd_sat | function | ||
| 2818 | core::core_arch::hexagon::v64 | Q6_Vuh_vasr_WwVuh_sat | function | ||
| 2819 | core::core_arch::hexagon::v64 | Q6_Vuh_vavg_VuhVuh | function | ||
| 2820 | core::core_arch::hexagon::v64 | Q6_Vuh_vavg_VuhVuh_rnd | function | ||
| 2821 | core::core_arch::hexagon::v64 | Q6_Vuh_vcl0_Vuh | function | ||
| 2822 | core::core_arch::hexagon::v64 | Q6_Vuh_vcvt_Vhf | function | ||
| 2823 | core::core_arch::hexagon::v64 | Q6_Vuh_vlsr_VuhR | function | ||
| 2824 | core::core_arch::hexagon::v64 | Q6_Vuh_vmax_VuhVuh | function | ||
| 2825 | core::core_arch::hexagon::v64 | Q6_Vuh_vmin_VuhVuh | function | ||
| 2826 | core::core_arch::hexagon::v64 | Q6_Vuh_vmpy_VuhVuh_rs16 | function | ||
| 2827 | core::core_arch::hexagon::v64 | Q6_Vuh_vpack_VwVw_sat | function | ||
| 2828 | core::core_arch::hexagon::v64 | Q6_Vuh_vround_VuwVuw_sat | function | ||
| 2829 | core::core_arch::hexagon::v64 | Q6_Vuh_vround_VwVw_sat | function | ||
| 2830 | core::core_arch::hexagon::v64 | Q6_Vuh_vsat_VuwVuw | function | ||
| 2831 | core::core_arch::hexagon::v64 | Q6_Vuh_vsub_VuhVuh_sat | function | ||
| 2832 | core::core_arch::hexagon::v64 | Q6_Vuw_vabsdiff_VwVw | function | ||
| 2833 | core::core_arch::hexagon::v64 | Q6_Vuw_vadd_VuwVuw_sat | function | ||
| 2834 | core::core_arch::hexagon::v64 | Q6_Vuw_vavg_VuwVuw | function | ||
| 2835 | core::core_arch::hexagon::v64 | Q6_Vuw_vavg_VuwVuw_rnd | function | ||
| 2836 | core::core_arch::hexagon::v64 | Q6_Vuw_vcl0_Vuw | function | ||
| 2837 | core::core_arch::hexagon::v64 | Q6_Vuw_vlsr_VuwR | function | ||
| 2838 | core::core_arch::hexagon::v64 | Q6_Vuw_vmpye_VuhRuh | function | ||
| 2839 | core::core_arch::hexagon::v64 | Q6_Vuw_vmpyeacc_VuwVuhRuh | function | ||
| 2840 | core::core_arch::hexagon::v64 | Q6_Vuw_vrmpy_VubRub | function | ||
| 2841 | core::core_arch::hexagon::v64 | Q6_Vuw_vrmpy_VubVub | function | ||
| 2842 | core::core_arch::hexagon::v64 | Q6_Vuw_vrmpyacc_VuwVubRub | function | ||
| 2843 | core::core_arch::hexagon::v64 | Q6_Vuw_vrmpyacc_VuwVubVub | function | ||
| 2844 | core::core_arch::hexagon::v64 | Q6_Vuw_vrotr_VuwVuw | function | ||
| 2845 | core::core_arch::hexagon::v64 | Q6_Vuw_vsub_VuwVuw_sat | function | ||
| 2846 | core::core_arch::hexagon::v64 | Q6_Vw_condacc_QVwVw | function | ||
| 2847 | core::core_arch::hexagon::v64 | Q6_Vw_condacc_QnVwVw | function | ||
| 2848 | core::core_arch::hexagon::v64 | Q6_Vw_condnac_QVwVw | function | ||
| 2849 | core::core_arch::hexagon::v64 | Q6_Vw_condnac_QnVwVw | function | ||
| 2850 | core::core_arch::hexagon::v64 | Q6_Vw_equals_Vsf | function | ||
| 2851 | core::core_arch::hexagon::v64 | Q6_Vw_prefixsum_Q | function | ||
| 2852 | core::core_arch::hexagon::v64 | Q6_Vw_vabs_Vw | function | ||
| 2853 | core::core_arch::hexagon::v64 | Q6_Vw_vabs_Vw_sat | function | ||
| 2854 | core::core_arch::hexagon::v64 | Q6_Vw_vadd_VwVw | function | ||
| 2855 | core::core_arch::hexagon::v64 | Q6_Vw_vadd_VwVwQ_carry_sat | function | ||
| 2856 | core::core_arch::hexagon::v64 | Q6_Vw_vadd_VwVw_sat | function | ||
| 2857 | core::core_arch::hexagon::v64 | Q6_Vw_vadd_vclb_VwVw | function | ||
| 2858 | core::core_arch::hexagon::v64 | Q6_Vw_vasl_VwR | function | ||
| 2859 | core::core_arch::hexagon::v64 | Q6_Vw_vasl_VwVw | function | ||
| 2860 | core::core_arch::hexagon::v64 | Q6_Vw_vaslacc_VwVwR | function | ||
| 2861 | core::core_arch::hexagon::v64 | Q6_Vw_vasr_VwR | function | ||
| 2862 | core::core_arch::hexagon::v64 | Q6_Vw_vasr_VwVw | function | ||
| 2863 | core::core_arch::hexagon::v64 | Q6_Vw_vasracc_VwVwR | function | ||
| 2864 | core::core_arch::hexagon::v64 | Q6_Vw_vavg_VwVw | function | ||
| 2865 | core::core_arch::hexagon::v64 | Q6_Vw_vavg_VwVw_rnd | function | ||
| 2866 | core::core_arch::hexagon::v64 | Q6_Vw_vdmpy_VhRb | function | ||
| 2867 | core::core_arch::hexagon::v64 | Q6_Vw_vdmpy_VhRh_sat | function | ||
| 2868 | core::core_arch::hexagon::v64 | Q6_Vw_vdmpy_VhRuh_sat | function | ||
| 2869 | core::core_arch::hexagon::v64 | Q6_Vw_vdmpy_VhVh_sat | function | ||
| 2870 | core::core_arch::hexagon::v64 | Q6_Vw_vdmpy_WhRh_sat | function | ||
| 2871 | core::core_arch::hexagon::v64 | Q6_Vw_vdmpy_WhRuh_sat | function | ||
| 2872 | core::core_arch::hexagon::v64 | Q6_Vw_vdmpyacc_VwVhRb | function | ||
| 2873 | core::core_arch::hexagon::v64 | Q6_Vw_vdmpyacc_VwVhRh_sat | function | ||
| 2874 | core::core_arch::hexagon::v64 | Q6_Vw_vdmpyacc_VwVhRuh_sat | function | ||
| 2875 | core::core_arch::hexagon::v64 | Q6_Vw_vdmpyacc_VwVhVh_sat | function | ||
| 2876 | core::core_arch::hexagon::v64 | Q6_Vw_vdmpyacc_VwWhRh_sat | function | ||
| 2877 | core::core_arch::hexagon::v64 | Q6_Vw_vdmpyacc_VwWhRuh_sat | function | ||
| 2878 | core::core_arch::hexagon::v64 | Q6_Vw_vfmv_Vw | function | ||
| 2879 | core::core_arch::hexagon::v64 | Q6_Vw_vinsert_VwR | function | ||
| 2880 | core::core_arch::hexagon::v64 | Q6_Vw_vlsr_VwVw | function | ||
| 2881 | core::core_arch::hexagon::v64 | Q6_Vw_vmax_VwVw | function | ||
| 2882 | core::core_arch::hexagon::v64 | Q6_Vw_vmin_VwVw | function | ||
| 2883 | core::core_arch::hexagon::v64 | Q6_Vw_vmpye_VwVuh | function | ||
| 2884 | core::core_arch::hexagon::v64 | Q6_Vw_vmpyi_VwRb | function | ||
| 2885 | core::core_arch::hexagon::v64 | Q6_Vw_vmpyi_VwRh | function | ||
| 2886 | core::core_arch::hexagon::v64 | Q6_Vw_vmpyi_VwRub | function | ||
| 2887 | core::core_arch::hexagon::v64 | Q6_Vw_vmpyiacc_VwVwRb | function | ||
| 2888 | core::core_arch::hexagon::v64 | Q6_Vw_vmpyiacc_VwVwRh | function | ||
| 2889 | core::core_arch::hexagon::v64 | Q6_Vw_vmpyiacc_VwVwRub | function | ||
| 2890 | core::core_arch::hexagon::v64 | Q6_Vw_vmpyie_VwVuh | function | ||
| 2891 | core::core_arch::hexagon::v64 | Q6_Vw_vmpyieacc_VwVwVh | function | ||
| 2892 | core::core_arch::hexagon::v64 | Q6_Vw_vmpyieacc_VwVwVuh | function | ||
| 2893 | core::core_arch::hexagon::v64 | Q6_Vw_vmpyieo_VhVh | function | ||
| 2894 | core::core_arch::hexagon::v64 | Q6_Vw_vmpyio_VwVh | function | ||
| 2895 | core::core_arch::hexagon::v64 | Q6_Vw_vmpyo_VwVh_s1_rnd_sat | function | ||
| 2896 | core::core_arch::hexagon::v64 | Q6_Vw_vmpyo_VwVh_s1_sat | function | ||
| 2897 | core::core_arch::hexagon::v64 | Q6_Vw_vmpyoacc_VwVwVh_s1_rnd_sat_shift | function | ||
| 2898 | core::core_arch::hexagon::v64 | Q6_Vw_vmpyoacc_VwVwVh_s1_sat_shift | function | ||
| 2899 | core::core_arch::hexagon::v64 | Q6_Vw_vnavg_VwVw | function | ||
| 2900 | core::core_arch::hexagon::v64 | Q6_Vw_vnormamt_Vw | function | ||
| 2901 | core::core_arch::hexagon::v64 | Q6_Vw_vrmpy_VbVb | function | ||
| 2902 | core::core_arch::hexagon::v64 | Q6_Vw_vrmpy_VubRb | function | ||
| 2903 | core::core_arch::hexagon::v64 | Q6_Vw_vrmpy_VubVb | function | ||
| 2904 | core::core_arch::hexagon::v64 | Q6_Vw_vrmpyacc_VwVbVb | function | ||
| 2905 | core::core_arch::hexagon::v64 | Q6_Vw_vrmpyacc_VwVubRb | function | ||
| 2906 | core::core_arch::hexagon::v64 | Q6_Vw_vrmpyacc_VwVubVb | function | ||
| 2907 | core::core_arch::hexagon::v64 | Q6_Vw_vsatdw_VwVw | function | ||
| 2908 | core::core_arch::hexagon::v64 | Q6_Vw_vsub_VwVw | function | ||
| 2909 | core::core_arch::hexagon::v64 | Q6_Vw_vsub_VwVw_sat | function | ||
| 2910 | core::core_arch::hexagon::v64 | Q6_W_equals_W | function | ||
| 2911 | core::core_arch::hexagon::v64 | Q6_W_vcombine_VV | function | ||
| 2912 | core::core_arch::hexagon::v64 | Q6_W_vdeal_VVR | function | ||
| 2913 | core::core_arch::hexagon::v64 | Q6_W_vmpye_VwVuh | function | ||
| 2914 | core::core_arch::hexagon::v64 | Q6_W_vmpyoacc_WVwVh | function | ||
| 2915 | core::core_arch::hexagon::v64 | Q6_W_vshuff_VVR | function | ||
| 2916 | core::core_arch::hexagon::v64 | Q6_W_vswap_QVV | function | ||
| 2917 | core::core_arch::hexagon::v64 | Q6_W_vzero | function | ||
| 2918 | core::core_arch::hexagon::v64 | Q6_Wb_vadd_WbWb | function | ||
| 2919 | core::core_arch::hexagon::v64 | Q6_Wb_vadd_WbWb_sat | function | ||
| 2920 | core::core_arch::hexagon::v64 | Q6_Wb_vshuffoe_VbVb | function | ||
| 2921 | core::core_arch::hexagon::v64 | Q6_Wb_vsub_WbWb | function | ||
| 2922 | core::core_arch::hexagon::v64 | Q6_Wb_vsub_WbWb_sat | function | ||
| 2923 | core::core_arch::hexagon::v64 | Q6_Wh_vadd_VubVub | function | ||
| 2924 | core::core_arch::hexagon::v64 | Q6_Wh_vadd_WhWh | function | ||
| 2925 | core::core_arch::hexagon::v64 | Q6_Wh_vadd_WhWh_sat | function | ||
| 2926 | core::core_arch::hexagon::v64 | Q6_Wh_vaddacc_WhVubVub | function | ||
| 2927 | core::core_arch::hexagon::v64 | Q6_Wh_vdmpy_WubRb | function | ||
| 2928 | core::core_arch::hexagon::v64 | Q6_Wh_vdmpyacc_WhWubRb | function | ||
| 2929 | core::core_arch::hexagon::v64 | Q6_Wh_vlut16_VbVhI | function | ||
| 2930 | core::core_arch::hexagon::v64 | Q6_Wh_vlut16_VbVhR | function | ||
| 2931 | core::core_arch::hexagon::v64 | Q6_Wh_vlut16_VbVhR_nomatch | function | ||
| 2932 | core::core_arch::hexagon::v64 | Q6_Wh_vlut16or_WhVbVhI | function | ||
| 2933 | core::core_arch::hexagon::v64 | Q6_Wh_vlut16or_WhVbVhR | function | ||
| 2934 | core::core_arch::hexagon::v64 | Q6_Wh_vmpa_WubRb | function | ||
| 2935 | core::core_arch::hexagon::v64 | Q6_Wh_vmpa_WubRub | function | ||
| 2936 | core::core_arch::hexagon::v64 | Q6_Wh_vmpa_WubWb | function | ||
| 2937 | core::core_arch::hexagon::v64 | Q6_Wh_vmpa_WubWub | function | ||
| 2938 | core::core_arch::hexagon::v64 | Q6_Wh_vmpaacc_WhWubRb | function | ||
| 2939 | core::core_arch::hexagon::v64 | Q6_Wh_vmpaacc_WhWubRub | function | ||
| 2940 | core::core_arch::hexagon::v64 | Q6_Wh_vmpy_VbVb | function | ||
| 2941 | core::core_arch::hexagon::v64 | Q6_Wh_vmpy_VubRb | function | ||
| 2942 | core::core_arch::hexagon::v64 | Q6_Wh_vmpy_VubVb | function | ||
| 2943 | core::core_arch::hexagon::v64 | Q6_Wh_vmpyacc_WhVbVb | function | ||
| 2944 | core::core_arch::hexagon::v64 | Q6_Wh_vmpyacc_WhVubRb | function | ||
| 2945 | core::core_arch::hexagon::v64 | Q6_Wh_vmpyacc_WhVubVb | function | ||
| 2946 | core::core_arch::hexagon::v64 | Q6_Wh_vshuffoe_VhVh | function | ||
| 2947 | core::core_arch::hexagon::v64 | Q6_Wh_vsub_VubVub | function | ||
| 2948 | core::core_arch::hexagon::v64 | Q6_Wh_vsub_WhWh | function | ||
| 2949 | core::core_arch::hexagon::v64 | Q6_Wh_vsub_WhWh_sat | function | ||
| 2950 | core::core_arch::hexagon::v64 | Q6_Wh_vsxt_Vb | function | ||
| 2951 | core::core_arch::hexagon::v64 | Q6_Wh_vtmpy_WbRb | function | ||
| 2952 | core::core_arch::hexagon::v64 | Q6_Wh_vtmpy_WubRb | function | ||
| 2953 | core::core_arch::hexagon::v64 | Q6_Wh_vtmpyacc_WhWbRb | function | ||
| 2954 | core::core_arch::hexagon::v64 | Q6_Wh_vtmpyacc_WhWubRb | function | ||
| 2955 | core::core_arch::hexagon::v64 | Q6_Wh_vunpack_Vb | function | ||
| 2956 | core::core_arch::hexagon::v64 | Q6_Wh_vunpackoor_WhVb | function | ||
| 2957 | core::core_arch::hexagon::v64 | Q6_Whf_vcvt2_Vb | function | ||
| 2958 | core::core_arch::hexagon::v64 | Q6_Whf_vcvt2_Vub | function | ||
| 2959 | core::core_arch::hexagon::v64 | Q6_Whf_vcvt_V | function | ||
| 2960 | core::core_arch::hexagon::v64 | Q6_Whf_vcvt_Vb | function | ||
| 2961 | core::core_arch::hexagon::v64 | Q6_Whf_vcvt_Vub | function | ||
| 2962 | core::core_arch::hexagon::v64 | Q6_Wqf32_vmpy_VhfVhf | function | ||
| 2963 | core::core_arch::hexagon::v64 | Q6_Wqf32_vmpy_Vqf16Vhf | function | ||
| 2964 | core::core_arch::hexagon::v64 | Q6_Wqf32_vmpy_Vqf16Vqf16 | function | ||
| 2965 | core::core_arch::hexagon::v64 | Q6_Wsf_vadd_VhfVhf | function | ||
| 2966 | core::core_arch::hexagon::v64 | Q6_Wsf_vcvt_Vhf | function | ||
| 2967 | core::core_arch::hexagon::v64 | Q6_Wsf_vmpy_VhfVhf | function | ||
| 2968 | core::core_arch::hexagon::v64 | Q6_Wsf_vmpyacc_WsfVhfVhf | function | ||
| 2969 | core::core_arch::hexagon::v64 | Q6_Wsf_vsub_VhfVhf | function | ||
| 2970 | core::core_arch::hexagon::v64 | Q6_Wub_vadd_WubWub_sat | function | ||
| 2971 | core::core_arch::hexagon::v64 | Q6_Wub_vsub_WubWub_sat | function | ||
| 2972 | core::core_arch::hexagon::v64 | Q6_Wuh_vadd_WuhWuh_sat | function | ||
| 2973 | core::core_arch::hexagon::v64 | Q6_Wuh_vmpy_VubRub | function | ||
| 2974 | core::core_arch::hexagon::v64 | Q6_Wuh_vmpy_VubVub | function | ||
| 2975 | core::core_arch::hexagon::v64 | Q6_Wuh_vmpyacc_WuhVubRub | function | ||
| 2976 | core::core_arch::hexagon::v64 | Q6_Wuh_vmpyacc_WuhVubVub | function | ||
| 2977 | core::core_arch::hexagon::v64 | Q6_Wuh_vsub_WuhWuh_sat | function | ||
| 2978 | core::core_arch::hexagon::v64 | Q6_Wuh_vunpack_Vub | function | ||
| 2979 | core::core_arch::hexagon::v64 | Q6_Wuh_vzxt_Vub | function | ||
| 2980 | core::core_arch::hexagon::v64 | Q6_Wuw_vadd_WuwWuw_sat | function | ||
| 2981 | core::core_arch::hexagon::v64 | Q6_Wuw_vdsad_WuhRuh | function | ||
| 2982 | core::core_arch::hexagon::v64 | Q6_Wuw_vdsadacc_WuwWuhRuh | function | ||
| 2983 | core::core_arch::hexagon::v64 | Q6_Wuw_vmpy_VuhRuh | function | ||
| 2984 | core::core_arch::hexagon::v64 | Q6_Wuw_vmpy_VuhVuh | function | ||
| 2985 | core::core_arch::hexagon::v64 | Q6_Wuw_vmpyacc_WuwVuhRuh | function | ||
| 2986 | core::core_arch::hexagon::v64 | Q6_Wuw_vmpyacc_WuwVuhVuh | function | ||
| 2987 | core::core_arch::hexagon::v64 | Q6_Wuw_vrmpy_WubRubI | function | ||
| 2988 | core::core_arch::hexagon::v64 | Q6_Wuw_vrmpyacc_WuwWubRubI | function | ||
| 2989 | core::core_arch::hexagon::v64 | Q6_Wuw_vrsad_WubRubI | function | ||
| 2990 | core::core_arch::hexagon::v64 | Q6_Wuw_vrsadacc_WuwWubRubI | function | ||
| 2991 | core::core_arch::hexagon::v64 | Q6_Wuw_vsub_WuwWuw_sat | function | ||
| 2992 | core::core_arch::hexagon::v64 | Q6_Wuw_vunpack_Vuh | function | ||
| 2993 | core::core_arch::hexagon::v64 | Q6_Wuw_vzxt_Vuh | function | ||
| 2994 | core::core_arch::hexagon::v64 | Q6_Ww_v6mpy_WubWbI_h | function | ||
| 2995 | core::core_arch::hexagon::v64 | Q6_Ww_v6mpy_WubWbI_v | function | ||
| 2996 | core::core_arch::hexagon::v64 | Q6_Ww_v6mpyacc_WwWubWbI_h | function | ||
| 2997 | core::core_arch::hexagon::v64 | Q6_Ww_v6mpyacc_WwWubWbI_v | function | ||
| 2998 | core::core_arch::hexagon::v64 | Q6_Ww_vadd_VhVh | function | ||
| 2999 | core::core_arch::hexagon::v64 | Q6_Ww_vadd_VuhVuh | function | ||
| 3000 | core::core_arch::hexagon::v64 | Q6_Ww_vadd_WwWw | function | ||
| 3001 | core::core_arch::hexagon::v64 | Q6_Ww_vadd_WwWw_sat | function | ||
| 3002 | core::core_arch::hexagon::v64 | Q6_Ww_vaddacc_WwVhVh | function | ||
| 3003 | core::core_arch::hexagon::v64 | Q6_Ww_vaddacc_WwVuhVuh | function | ||
| 3004 | core::core_arch::hexagon::v64 | Q6_Ww_vasrinto_WwVwVw | function | ||
| 3005 | core::core_arch::hexagon::v64 | Q6_Ww_vdmpy_WhRb | function | ||
| 3006 | core::core_arch::hexagon::v64 | Q6_Ww_vdmpyacc_WwWhRb | function | ||
| 3007 | core::core_arch::hexagon::v64 | Q6_Ww_vmpa_WhRb | function | ||
| 3008 | core::core_arch::hexagon::v64 | Q6_Ww_vmpa_WuhRb | function | ||
| 3009 | core::core_arch::hexagon::v64 | Q6_Ww_vmpaacc_WwWhRb | function | ||
| 3010 | core::core_arch::hexagon::v64 | Q6_Ww_vmpaacc_WwWuhRb | function | ||
| 3011 | core::core_arch::hexagon::v64 | Q6_Ww_vmpy_VhRh | function | ||
| 3012 | core::core_arch::hexagon::v64 | Q6_Ww_vmpy_VhVh | function | ||
| 3013 | core::core_arch::hexagon::v64 | Q6_Ww_vmpy_VhVuh | function | ||
| 3014 | core::core_arch::hexagon::v64 | Q6_Ww_vmpyacc_WwVhRh | function | ||
| 3015 | core::core_arch::hexagon::v64 | Q6_Ww_vmpyacc_WwVhRh_sat | function | ||
| 3016 | core::core_arch::hexagon::v64 | Q6_Ww_vmpyacc_WwVhVh | function | ||
| 3017 | core::core_arch::hexagon::v64 | Q6_Ww_vmpyacc_WwVhVuh | function | ||
| 3018 | core::core_arch::hexagon::v64 | Q6_Ww_vrmpy_WubRbI | function | ||
| 3019 | core::core_arch::hexagon::v64 | Q6_Ww_vrmpyacc_WwWubRbI | function | ||
| 3020 | core::core_arch::hexagon::v64 | Q6_Ww_vsub_VhVh | function | ||
| 3021 | core::core_arch::hexagon::v64 | Q6_Ww_vsub_VuhVuh | function | ||
| 3022 | core::core_arch::hexagon::v64 | Q6_Ww_vsub_WwWw | function | ||
| 3023 | core::core_arch::hexagon::v64 | Q6_Ww_vsub_WwWw_sat | function | ||
| 3024 | core::core_arch::hexagon::v64 | Q6_Ww_vsxt_Vh | function | ||
| 3025 | core::core_arch::hexagon::v64 | Q6_Ww_vtmpy_WhRb | function | ||
| 3026 | core::core_arch::hexagon::v64 | Q6_Ww_vtmpyacc_WwWhRb | function | ||
| 3027 | core::core_arch::hexagon::v64 | Q6_Ww_vunpack_Vh | function | ||
| 3028 | core::core_arch::hexagon::v64 | Q6_Ww_vunpackoor_WwVh | function | ||
| 3029 | core::core_arch::hexagon::v64 | Q6_vgather_AQRMVh | function | ||
| 3030 | core::core_arch::hexagon::v64 | Q6_vgather_AQRMVw | function | ||
| 3031 | core::core_arch::hexagon::v64 | Q6_vgather_AQRMWw | function | ||
| 3032 | core::core_arch::hexagon::v64 | Q6_vgather_ARMVh | function | ||
| 3033 | core::core_arch::hexagon::v64 | Q6_vgather_ARMVw | function | ||
| 3034 | core::core_arch::hexagon::v64 | Q6_vgather_ARMWw | function | ||
| 3035 | core::core_arch::hexagon::v64 | Q6_vmem_QRIV | function | ||
| 3036 | core::core_arch::hexagon::v64 | Q6_vmem_QRIV_nt | function | ||
| 3037 | core::core_arch::hexagon::v64 | Q6_vmem_QnRIV | function | ||
| 3038 | core::core_arch::hexagon::v64 | Q6_vmem_QnRIV_nt | function | ||
| 3039 | core::core_arch::hexagon::v64 | Q6_vscatter_QRMVhV | function | ||
| 3040 | core::core_arch::hexagon::v64 | Q6_vscatter_QRMVwV | function | ||
| 3041 | core::core_arch::hexagon::v64 | Q6_vscatter_QRMWwV | function | ||
| 3042 | core::core_arch::hexagon::v64 | Q6_vscatter_RMVhV | function | ||
| 3043 | core::core_arch::hexagon::v64 | Q6_vscatter_RMVwV | function | ||
| 3044 | core::core_arch::hexagon::v64 | Q6_vscatter_RMWwV | function | ||
| 3045 | core::core_arch::hexagon::v64 | Q6_vscatteracc_RMVhV | function | ||
| 3046 | core::core_arch::hexagon::v64 | Q6_vscatteracc_RMVwV | function | ||
| 3047 | core::core_arch::hexagon::v64 | Q6_vscatteracc_RMWwV | function | ||
| 3048 | core::core_arch::loongarch32 | cacop | function | ||
| 3049 | core::core_arch::loongarch32 | csrrd | function | ||
| 3050 | core::core_arch::loongarch32 | csrwr | function | ||
| 3051 | core::core_arch::loongarch32 | csrxchg | function | ||
| 3052 | core::core_arch::loongarch64 | asrtgt | function | ||
| 3053 | core::core_arch::loongarch64 | asrtle | function | ||
| 3054 | core::core_arch::loongarch64 | cacop | function | ||
| 3055 | core::core_arch::loongarch64 | csrrd | function | ||
| 3056 | core::core_arch::loongarch64 | csrwr | function | ||
| 3057 | core::core_arch::loongarch64 | csrxchg | function | ||
| 3058 | core::core_arch::loongarch64 | iocsrrd_d | function | ||
| 3059 | core::core_arch::loongarch64 | iocsrwr_d | function | ||
| 3060 | core::core_arch::loongarch64 | lddir | function | ||
| 3061 | core::core_arch::loongarch64 | ldpte | function | ||
| 3062 | core::core_arch::loongarch64::lasx::generated | lasx_xvld | function | ||
| 3063 | core::core_arch::loongarch64::lasx::generated | lasx_xvldrepl_b | function | ||
| 3064 | core::core_arch::loongarch64::lasx::generated | lasx_xvldrepl_d | function | ||
| 3065 | core::core_arch::loongarch64::lasx::generated | lasx_xvldrepl_h | function | ||
| 3066 | core::core_arch::loongarch64::lasx::generated | lasx_xvldrepl_w | function | ||
| 3067 | core::core_arch::loongarch64::lasx::generated | lasx_xvldx | function | ||
| 3068 | core::core_arch::loongarch64::lasx::generated | lasx_xvst | function | ||
| 3069 | core::core_arch::loongarch64::lasx::generated | lasx_xvstelm_b | function | ||
| 3070 | core::core_arch::loongarch64::lasx::generated | lasx_xvstelm_d | function | ||
| 3071 | core::core_arch::loongarch64::lasx::generated | lasx_xvstelm_h | function | ||
| 3072 | core::core_arch::loongarch64::lasx::generated | lasx_xvstelm_w | function | ||
| 3073 | core::core_arch::loongarch64::lasx::generated | lasx_xvstx | function | ||
| 3074 | core::core_arch::loongarch64::lsx::generated | lsx_vld | function | ||
| 3075 | core::core_arch::loongarch64::lsx::generated | lsx_vldrepl_b | function | ||
| 3076 | core::core_arch::loongarch64::lsx::generated | lsx_vldrepl_d | function | ||
| 3077 | core::core_arch::loongarch64::lsx::generated | lsx_vldrepl_h | function | ||
| 3078 | core::core_arch::loongarch64::lsx::generated | lsx_vldrepl_w | function | ||
| 3079 | core::core_arch::loongarch64::lsx::generated | lsx_vldx | function | ||
| 3080 | core::core_arch::loongarch64::lsx::generated | lsx_vst | function | ||
| 3081 | core::core_arch::loongarch64::lsx::generated | lsx_vstelm_b | function | ||
| 3082 | core::core_arch::loongarch64::lsx::generated | lsx_vstelm_d | function | ||
| 3083 | core::core_arch::loongarch64::lsx::generated | lsx_vstelm_h | function | ||
| 3084 | core::core_arch::loongarch64::lsx::generated | lsx_vstelm_w | function | ||
| 3085 | core::core_arch::loongarch64::lsx::generated | lsx_vstx | function | ||
| 3086 | core::core_arch::loongarch_shared | brk | function | ||
| 3087 | core::core_arch::loongarch_shared | iocsrrd_b | function | ||
| 3088 | core::core_arch::loongarch_shared | iocsrrd_h | function | ||
| 3089 | core::core_arch::loongarch_shared | iocsrrd_w | function | ||
| 3090 | core::core_arch::loongarch_shared | iocsrwr_b | function | ||
| 3091 | core::core_arch::loongarch_shared | iocsrwr_h | function | ||
| 3092 | core::core_arch::loongarch_shared | iocsrwr_w | function | ||
| 3093 | core::core_arch::loongarch_shared | movgr2fcsr | function | ||
| 3094 | core::core_arch::loongarch_shared | syscall | function | ||
| 3095 | core::core_arch::mips | break_ | function | ||
| 3096 | core::core_arch::nvptx | __assert_fail | function | ||
| 3097 | core::core_arch::nvptx | _block_dim_x | function | ||
| 3098 | core::core_arch::nvptx | _block_dim_y | function | ||
| 3099 | core::core_arch::nvptx | _block_dim_z | function | ||
| 3100 | core::core_arch::nvptx | _block_idx_x | function | ||
| 3101 | core::core_arch::nvptx | _block_idx_y | function | ||
| 3102 | core::core_arch::nvptx | _block_idx_z | function | ||
| 3103 | core::core_arch::nvptx | _grid_dim_x | function | ||
| 3104 | core::core_arch::nvptx | _grid_dim_y | function | ||
| 3105 | core::core_arch::nvptx | _grid_dim_z | function | ||
| 3106 | core::core_arch::nvptx | _syncthreads | function | ||
| 3107 | core::core_arch::nvptx | _thread_idx_x | function | ||
| 3108 | core::core_arch::nvptx | _thread_idx_y | function | ||
| 3109 | core::core_arch::nvptx | _thread_idx_z | function | ||
| 3110 | core::core_arch::nvptx | free | function | ||
| 3111 | core::core_arch::nvptx | malloc | function | ||
| 3112 | core::core_arch::nvptx | trap | function | ||
| 3113 | core::core_arch::nvptx | vprintf | function | ||
| 3114 | core::core_arch::nvptx::packed | f16x2_add | function | ||
| 3115 | core::core_arch::nvptx::packed | f16x2_fma | function | ||
| 3116 | core::core_arch::nvptx::packed | f16x2_max | function | ||
| 3117 | core::core_arch::nvptx::packed | f16x2_max_nan | function | ||
| 3118 | core::core_arch::nvptx::packed | f16x2_min | function | ||
| 3119 | core::core_arch::nvptx::packed | f16x2_min_nan | function | ||
| 3120 | core::core_arch::nvptx::packed | f16x2_mul | function | ||
| 3121 | core::core_arch::nvptx::packed | f16x2_neg | function | ||
| 3122 | core::core_arch::nvptx::packed | f16x2_sub | function | ||
| 3123 | core::core_arch::powerpc | trap | function | ||
| 3124 | core::core_arch::powerpc64::vsx | vec_xl_len | function | ||
| 3125 | core::core_arch::powerpc64::vsx | vec_xst_len | function | ||
| 3126 | core::core_arch::powerpc::altivec | vec_abs | function | ||
| 3127 | core::core_arch::powerpc::altivec | vec_abss | function | ||
| 3128 | core::core_arch::powerpc::altivec | vec_add | function | ||
| 3129 | core::core_arch::powerpc::altivec | vec_addc | function | ||
| 3130 | core::core_arch::powerpc::altivec | vec_adde | function | ||
| 3131 | core::core_arch::powerpc::altivec | vec_adds | function | ||
| 3132 | core::core_arch::powerpc::altivec | vec_all_eq | function | ||
| 3133 | core::core_arch::powerpc::altivec | vec_all_ge | function | ||
| 3134 | core::core_arch::powerpc::altivec | vec_all_gt | function | ||
| 3135 | core::core_arch::powerpc::altivec | vec_all_in | function | ||
| 3136 | core::core_arch::powerpc::altivec | vec_all_le | function | ||
| 3137 | core::core_arch::powerpc::altivec | vec_all_lt | function | ||
| 3138 | core::core_arch::powerpc::altivec | vec_all_nan | function | ||
| 3139 | core::core_arch::powerpc::altivec | vec_all_ne | function | ||
| 3140 | core::core_arch::powerpc::altivec | vec_all_nge | function | ||
| 3141 | core::core_arch::powerpc::altivec | vec_all_ngt | function | ||
| 3142 | core::core_arch::powerpc::altivec | vec_all_nle | function | ||
| 3143 | core::core_arch::powerpc::altivec | vec_all_nlt | function | ||
| 3144 | core::core_arch::powerpc::altivec | vec_all_numeric | function | ||
| 3145 | core::core_arch::powerpc::altivec | vec_and | function | ||
| 3146 | core::core_arch::powerpc::altivec | vec_andc | function | ||
| 3147 | core::core_arch::powerpc::altivec | vec_any_eq | function | ||
| 3148 | core::core_arch::powerpc::altivec | vec_any_ge | function | ||
| 3149 | core::core_arch::powerpc::altivec | vec_any_gt | function | ||
| 3150 | core::core_arch::powerpc::altivec | vec_any_le | function | ||
| 3151 | core::core_arch::powerpc::altivec | vec_any_lt | function | ||
| 3152 | core::core_arch::powerpc::altivec | vec_any_nan | function | ||
| 3153 | core::core_arch::powerpc::altivec | vec_any_ne | function | ||
| 3154 | core::core_arch::powerpc::altivec | vec_any_nge | function | ||
| 3155 | core::core_arch::powerpc::altivec | vec_any_ngt | function | ||
| 3156 | core::core_arch::powerpc::altivec | vec_any_nle | function | ||
| 3157 | core::core_arch::powerpc::altivec | vec_any_nlt | function | ||
| 3158 | core::core_arch::powerpc::altivec | vec_any_numeric | function | ||
| 3159 | core::core_arch::powerpc::altivec | vec_any_out | function | ||
| 3160 | core::core_arch::powerpc::altivec | vec_avg | function | ||
| 3161 | core::core_arch::powerpc::altivec | vec_ceil | function | ||
| 3162 | core::core_arch::powerpc::altivec | vec_cmpb | function | ||
| 3163 | core::core_arch::powerpc::altivec | vec_cmpeq | function | ||
| 3164 | core::core_arch::powerpc::altivec | vec_cmpge | function | ||
| 3165 | core::core_arch::powerpc::altivec | vec_cmpgt | function | ||
| 3166 | core::core_arch::powerpc::altivec | vec_cmple | function | ||
| 3167 | core::core_arch::powerpc::altivec | vec_cmplt | function | ||
| 3168 | core::core_arch::powerpc::altivec | vec_cmpne | function | ||
| 3169 | core::core_arch::powerpc::altivec | vec_cntlz | function | ||
| 3170 | core::core_arch::powerpc::altivec | vec_ctf | function | ||
| 3171 | core::core_arch::powerpc::altivec | vec_cts | function | ||
| 3172 | core::core_arch::powerpc::altivec | vec_ctu | function | ||
| 3173 | core::core_arch::powerpc::altivec | vec_expte | function | ||
| 3174 | core::core_arch::powerpc::altivec | vec_extract | function | ||
| 3175 | core::core_arch::powerpc::altivec | vec_floor | function | ||
| 3176 | core::core_arch::powerpc::altivec | vec_insert | function | ||
| 3177 | core::core_arch::powerpc::altivec | vec_ld | function | ||
| 3178 | core::core_arch::powerpc::altivec | vec_lde | function | ||
| 3179 | core::core_arch::powerpc::altivec | vec_ldl | function | ||
| 3180 | core::core_arch::powerpc::altivec | vec_loge | function | ||
| 3181 | core::core_arch::powerpc::altivec | vec_madd | function | ||
| 3182 | core::core_arch::powerpc::altivec | vec_madds | function | ||
| 3183 | core::core_arch::powerpc::altivec | vec_max | function | ||
| 3184 | core::core_arch::powerpc::altivec | vec_mergeh | function | ||
| 3185 | core::core_arch::powerpc::altivec | vec_mergel | function | ||
| 3186 | core::core_arch::powerpc::altivec | vec_mfvscr | function | ||
| 3187 | core::core_arch::powerpc::altivec | vec_min | function | ||
| 3188 | core::core_arch::powerpc::altivec | vec_mladd | function | ||
| 3189 | core::core_arch::powerpc::altivec | vec_mradds | function | ||
| 3190 | core::core_arch::powerpc::altivec | vec_msum | function | ||
| 3191 | core::core_arch::powerpc::altivec | vec_msums | function | ||
| 3192 | core::core_arch::powerpc::altivec | vec_mul | function | ||
| 3193 | core::core_arch::powerpc::altivec | vec_nand | function | ||
| 3194 | core::core_arch::powerpc::altivec | vec_neg | function | ||
| 3195 | core::core_arch::powerpc::altivec | vec_nmsub | function | ||
| 3196 | core::core_arch::powerpc::altivec | vec_nor | function | ||
| 3197 | core::core_arch::powerpc::altivec | vec_or | function | ||
| 3198 | core::core_arch::powerpc::altivec | vec_orc | function | ||
| 3199 | core::core_arch::powerpc::altivec | vec_pack | function | ||
| 3200 | core::core_arch::powerpc::altivec | vec_packs | function | ||
| 3201 | core::core_arch::powerpc::altivec | vec_packsu | function | ||
| 3202 | core::core_arch::powerpc::altivec | vec_rl | function | ||
| 3203 | core::core_arch::powerpc::altivec | vec_round | function | ||
| 3204 | core::core_arch::powerpc::altivec | vec_sel | function | ||
| 3205 | core::core_arch::powerpc::altivec | vec_sl | function | ||
| 3206 | core::core_arch::powerpc::altivec | vec_sld | function | ||
| 3207 | core::core_arch::powerpc::altivec | vec_sldw | function | ||
| 3208 | core::core_arch::powerpc::altivec | vec_sll | function | ||
| 3209 | core::core_arch::powerpc::altivec | vec_slo | function | ||
| 3210 | core::core_arch::powerpc::altivec | vec_slv | function | ||
| 3211 | core::core_arch::powerpc::altivec | vec_splat | function | ||
| 3212 | core::core_arch::powerpc::altivec | vec_splat_s16 | function | ||
| 3213 | core::core_arch::powerpc::altivec | vec_splat_s32 | function | ||
| 3214 | core::core_arch::powerpc::altivec | vec_splat_s8 | function | ||
| 3215 | core::core_arch::powerpc::altivec | vec_splat_u16 | function | ||
| 3216 | core::core_arch::powerpc::altivec | vec_splat_u32 | function | ||
| 3217 | core::core_arch::powerpc::altivec | vec_splat_u8 | function | ||
| 3218 | core::core_arch::powerpc::altivec | vec_splats | function | ||
| 3219 | core::core_arch::powerpc::altivec | vec_sr | function | ||
| 3220 | core::core_arch::powerpc::altivec | vec_sra | function | ||
| 3221 | core::core_arch::powerpc::altivec | vec_srl | function | ||
| 3222 | core::core_arch::powerpc::altivec | vec_sro | function | ||
| 3223 | core::core_arch::powerpc::altivec | vec_srv | function | ||
| 3224 | core::core_arch::powerpc::altivec | vec_st | function | ||
| 3225 | core::core_arch::powerpc::altivec | vec_ste | function | ||
| 3226 | core::core_arch::powerpc::altivec | vec_stl | function | ||
| 3227 | core::core_arch::powerpc::altivec | vec_sub | function | ||
| 3228 | core::core_arch::powerpc::altivec | vec_subc | function | ||
| 3229 | core::core_arch::powerpc::altivec | vec_subs | function | ||
| 3230 | core::core_arch::powerpc::altivec | vec_sum4s | function | ||
| 3231 | core::core_arch::powerpc::altivec | vec_unpackh | function | ||
| 3232 | core::core_arch::powerpc::altivec | vec_unpackl | function | ||
| 3233 | core::core_arch::powerpc::altivec | vec_xl | function | ||
| 3234 | core::core_arch::powerpc::altivec | vec_xor | function | ||
| 3235 | core::core_arch::powerpc::altivec | vec_xst | function | ||
| 3236 | core::core_arch::powerpc::altivec::endian | vec_mule | function | ||
| 3237 | core::core_arch::powerpc::altivec::endian | vec_mulo | function | ||
| 3238 | core::core_arch::powerpc::altivec::endian | vec_perm | function | ||
| 3239 | core::core_arch::powerpc::altivec::endian | vec_sum2s | function | ||
| 3240 | core::core_arch::powerpc::vsx | vec_mergee | function | ||
| 3241 | core::core_arch::powerpc::vsx | vec_mergeo | function | ||
| 3242 | core::core_arch::powerpc::vsx | vec_xxpermdi | function | ||
| 3243 | core::core_arch::riscv64 | hlv_d | function | ||
| 3244 | core::core_arch::riscv64 | hlv_wu | function | ||
| 3245 | core::core_arch::riscv64 | hsv_d | function | ||
| 3246 | core::core_arch::riscv_shared | fence_i | function | ||
| 3247 | core::core_arch::riscv_shared | hfence_gvma | function | ||
| 3248 | core::core_arch::riscv_shared | hfence_gvma_all | function | ||
| 3249 | core::core_arch::riscv_shared | hfence_gvma_gaddr | function | ||
| 3250 | core::core_arch::riscv_shared | hfence_gvma_vmid | function | ||
| 3251 | core::core_arch::riscv_shared | hfence_vvma | function | ||
| 3252 | core::core_arch::riscv_shared | hfence_vvma_all | function | ||
| 3253 | core::core_arch::riscv_shared | hfence_vvma_asid | function | ||
| 3254 | core::core_arch::riscv_shared | hfence_vvma_vaddr | function | ||
| 3255 | core::core_arch::riscv_shared | hinval_gvma | function | ||
| 3256 | core::core_arch::riscv_shared | hinval_gvma_all | function | ||
| 3257 | core::core_arch::riscv_shared | hinval_gvma_gaddr | function | ||
| 3258 | core::core_arch::riscv_shared | hinval_gvma_vmid | function | ||
| 3259 | core::core_arch::riscv_shared | hinval_vvma | function | ||
| 3260 | core::core_arch::riscv_shared | hinval_vvma_all | function | ||
| 3261 | core::core_arch::riscv_shared | hinval_vvma_asid | function | ||
| 3262 | core::core_arch::riscv_shared | hinval_vvma_vaddr | function | ||
| 3263 | core::core_arch::riscv_shared | hlv_b | function | ||
| 3264 | core::core_arch::riscv_shared | hlv_bu | function | ||
| 3265 | core::core_arch::riscv_shared | hlv_h | function | ||
| 3266 | core::core_arch::riscv_shared | hlv_hu | function | ||
| 3267 | core::core_arch::riscv_shared | hlv_w | function | ||
| 3268 | core::core_arch::riscv_shared | hlvx_hu | function | ||
| 3269 | core::core_arch::riscv_shared | hlvx_wu | function | ||
| 3270 | core::core_arch::riscv_shared | hsv_b | function | ||
| 3271 | core::core_arch::riscv_shared | hsv_h | function | ||
| 3272 | core::core_arch::riscv_shared | hsv_w | function | ||
| 3273 | core::core_arch::riscv_shared | sfence_inval_ir | function | ||
| 3274 | core::core_arch::riscv_shared | sfence_vma | function | ||
| 3275 | core::core_arch::riscv_shared | sfence_vma_all | function | ||
| 3276 | core::core_arch::riscv_shared | sfence_vma_asid | function | ||
| 3277 | core::core_arch::riscv_shared | sfence_vma_vaddr | function | ||
| 3278 | core::core_arch::riscv_shared | sfence_w_inval | function | ||
| 3279 | core::core_arch::riscv_shared | sinval_vma | function | ||
| 3280 | core::core_arch::riscv_shared | sinval_vma_all | function | ||
| 3281 | core::core_arch::riscv_shared | sinval_vma_asid | function | ||
| 3282 | core::core_arch::riscv_shared | sinval_vma_vaddr | function | ||
| 3283 | core::core_arch::riscv_shared | wfi | function | ||
| 3284 | core::core_arch::s390x::vector | vec_abs | function | ||
| 3285 | core::core_arch::s390x::vector | vec_add | function | ||
| 3286 | core::core_arch::s390x::vector | vec_add_u128 | function | ||
| 3287 | core::core_arch::s390x::vector | vec_addc_u128 | function | ||
| 3288 | core::core_arch::s390x::vector | vec_adde_u128 | function | ||
| 3289 | core::core_arch::s390x::vector | vec_addec_u128 | function | ||
| 3290 | core::core_arch::s390x::vector | vec_all_eq | function | ||
| 3291 | core::core_arch::s390x::vector | vec_all_ge | function | ||
| 3292 | core::core_arch::s390x::vector | vec_all_gt | function | ||
| 3293 | core::core_arch::s390x::vector | vec_all_le | function | ||
| 3294 | core::core_arch::s390x::vector | vec_all_lt | function | ||
| 3295 | core::core_arch::s390x::vector | vec_all_nan | function | ||
| 3296 | core::core_arch::s390x::vector | vec_all_ne | function | ||
| 3297 | core::core_arch::s390x::vector | vec_all_nge | function | ||
| 3298 | core::core_arch::s390x::vector | vec_all_ngt | function | ||
| 3299 | core::core_arch::s390x::vector | vec_all_nle | function | ||
| 3300 | core::core_arch::s390x::vector | vec_all_nlt | function | ||
| 3301 | core::core_arch::s390x::vector | vec_all_numeric | function | ||
| 3302 | core::core_arch::s390x::vector | vec_and | function | ||
| 3303 | core::core_arch::s390x::vector | vec_andc | function | ||
| 3304 | core::core_arch::s390x::vector | vec_any_eq | function | ||
| 3305 | core::core_arch::s390x::vector | vec_any_ge | function | ||
| 3306 | core::core_arch::s390x::vector | vec_any_gt | function | ||
| 3307 | core::core_arch::s390x::vector | vec_any_le | function | ||
| 3308 | core::core_arch::s390x::vector | vec_any_lt | function | ||
| 3309 | core::core_arch::s390x::vector | vec_any_nan | function | ||
| 3310 | core::core_arch::s390x::vector | vec_any_ne | function | ||
| 3311 | core::core_arch::s390x::vector | vec_any_nge | function | ||
| 3312 | core::core_arch::s390x::vector | vec_any_ngt | function | ||
| 3313 | core::core_arch::s390x::vector | vec_any_nle | function | ||
| 3314 | core::core_arch::s390x::vector | vec_any_nlt | function | ||
| 3315 | core::core_arch::s390x::vector | vec_any_numeric | function | ||
| 3316 | core::core_arch::s390x::vector | vec_avg | function | ||
| 3317 | core::core_arch::s390x::vector | vec_bperm_u128 | function | ||
| 3318 | core::core_arch::s390x::vector | vec_ceil | function | ||
| 3319 | core::core_arch::s390x::vector | vec_checksum | function | ||
| 3320 | core::core_arch::s390x::vector | vec_cmpeq | function | ||
| 3321 | core::core_arch::s390x::vector | vec_cmpeq_idx | function | ||
| 3322 | core::core_arch::s390x::vector | vec_cmpeq_idx_cc | function | ||
| 3323 | core::core_arch::s390x::vector | vec_cmpeq_or_0_idx | function | ||
| 3324 | core::core_arch::s390x::vector | vec_cmpeq_or_0_idx_cc | function | ||
| 3325 | core::core_arch::s390x::vector | vec_cmpge | function | ||
| 3326 | core::core_arch::s390x::vector | vec_cmpgt | function | ||
| 3327 | core::core_arch::s390x::vector | vec_cmple | function | ||
| 3328 | core::core_arch::s390x::vector | vec_cmplt | function | ||
| 3329 | core::core_arch::s390x::vector | vec_cmpne | function | ||
| 3330 | core::core_arch::s390x::vector | vec_cmpne_idx | function | ||
| 3331 | core::core_arch::s390x::vector | vec_cmpne_idx_cc | function | ||
| 3332 | core::core_arch::s390x::vector | vec_cmpne_or_0_idx | function | ||
| 3333 | core::core_arch::s390x::vector | vec_cmpne_or_0_idx_cc | function | ||
| 3334 | core::core_arch::s390x::vector | vec_cmpnrg | function | ||
| 3335 | core::core_arch::s390x::vector | vec_cmpnrg_cc | function | ||
| 3336 | core::core_arch::s390x::vector | vec_cmpnrg_idx | function | ||
| 3337 | core::core_arch::s390x::vector | vec_cmpnrg_idx_cc | function | ||
| 3338 | core::core_arch::s390x::vector | vec_cmpnrg_or_0_idx | function | ||
| 3339 | core::core_arch::s390x::vector | vec_cmpnrg_or_0_idx_cc | function | ||
| 3340 | core::core_arch::s390x::vector | vec_cmprg | function | ||
| 3341 | core::core_arch::s390x::vector | vec_cmprg_cc | function | ||
| 3342 | core::core_arch::s390x::vector | vec_cmprg_idx | function | ||
| 3343 | core::core_arch::s390x::vector | vec_cmprg_idx_cc | function | ||
| 3344 | core::core_arch::s390x::vector | vec_cmprg_or_0_idx | function | ||
| 3345 | core::core_arch::s390x::vector | vec_cmprg_or_0_idx_cc | function | ||
| 3346 | core::core_arch::s390x::vector | vec_cntlz | function | ||
| 3347 | core::core_arch::s390x::vector | vec_cnttz | function | ||
| 3348 | core::core_arch::s390x::vector | vec_convert_from_fp16 | function | ||
| 3349 | core::core_arch::s390x::vector | vec_convert_to_fp16 | function | ||
| 3350 | core::core_arch::s390x::vector | vec_cp_until_zero | function | ||
| 3351 | core::core_arch::s390x::vector | vec_cp_until_zero_cc | function | ||
| 3352 | core::core_arch::s390x::vector | vec_double | function | ||
| 3353 | core::core_arch::s390x::vector | vec_doublee | function | ||
| 3354 | core::core_arch::s390x::vector | vec_eqv | function | ||
| 3355 | core::core_arch::s390x::vector | vec_extend_s64 | function | ||
| 3356 | core::core_arch::s390x::vector | vec_extend_to_fp32_hi | function | ||
| 3357 | core::core_arch::s390x::vector | vec_extend_to_fp32_lo | function | ||
| 3358 | core::core_arch::s390x::vector | vec_extract | function | ||
| 3359 | core::core_arch::s390x::vector | vec_find_any_eq | function | ||
| 3360 | core::core_arch::s390x::vector | vec_find_any_eq_cc | function | ||
| 3361 | core::core_arch::s390x::vector | vec_find_any_eq_idx | function | ||
| 3362 | core::core_arch::s390x::vector | vec_find_any_eq_idx_cc | function | ||
| 3363 | core::core_arch::s390x::vector | vec_find_any_eq_or_0_idx | function | ||
| 3364 | core::core_arch::s390x::vector | vec_find_any_eq_or_0_idx_cc | function | ||
| 3365 | core::core_arch::s390x::vector | vec_find_any_ne | function | ||
| 3366 | core::core_arch::s390x::vector | vec_find_any_ne_cc | function | ||
| 3367 | core::core_arch::s390x::vector | vec_find_any_ne_idx | function | ||
| 3368 | core::core_arch::s390x::vector | vec_find_any_ne_idx_cc | function | ||
| 3369 | core::core_arch::s390x::vector | vec_find_any_ne_or_0_idx | function | ||
| 3370 | core::core_arch::s390x::vector | vec_find_any_ne_or_0_idx_cc | function | ||
| 3371 | core::core_arch::s390x::vector | vec_float | function | ||
| 3372 | core::core_arch::s390x::vector | vec_floate | function | ||
| 3373 | core::core_arch::s390x::vector | vec_floor | function | ||
| 3374 | core::core_arch::s390x::vector | vec_fp_test_data_class | function | ||
| 3375 | core::core_arch::s390x::vector | vec_gather_element | function | ||
| 3376 | core::core_arch::s390x::vector | vec_genmask | function | ||
| 3377 | core::core_arch::s390x::vector | vec_genmasks_16 | function | ||
| 3378 | core::core_arch::s390x::vector | vec_genmasks_32 | function | ||
| 3379 | core::core_arch::s390x::vector | vec_genmasks_64 | function | ||
| 3380 | core::core_arch::s390x::vector | vec_genmasks_8 | function | ||
| 3381 | core::core_arch::s390x::vector | vec_gfmsum | function | ||
| 3382 | core::core_arch::s390x::vector | vec_gfmsum_128 | function | ||
| 3383 | core::core_arch::s390x::vector | vec_gfmsum_accum | function | ||
| 3384 | core::core_arch::s390x::vector | vec_gfmsum_accum_128 | function | ||
| 3385 | core::core_arch::s390x::vector | vec_insert | function | ||
| 3386 | core::core_arch::s390x::vector | vec_insert_and_zero | function | ||
| 3387 | core::core_arch::s390x::vector | vec_load_bndry | function | ||
| 3388 | core::core_arch::s390x::vector | vec_load_len | function | ||
| 3389 | core::core_arch::s390x::vector | vec_load_len_r | function | ||
| 3390 | core::core_arch::s390x::vector | vec_load_pair | function | ||
| 3391 | core::core_arch::s390x::vector | vec_madd | function | ||
| 3392 | core::core_arch::s390x::vector | vec_max | function | ||
| 3393 | core::core_arch::s390x::vector | vec_meadd | function | ||
| 3394 | core::core_arch::s390x::vector | vec_mergeh | function | ||
| 3395 | core::core_arch::s390x::vector | vec_mergel | function | ||
| 3396 | core::core_arch::s390x::vector | vec_mhadd | function | ||
| 3397 | core::core_arch::s390x::vector | vec_min | function | ||
| 3398 | core::core_arch::s390x::vector | vec_mladd | function | ||
| 3399 | core::core_arch::s390x::vector | vec_moadd | function | ||
| 3400 | core::core_arch::s390x::vector | vec_msub | function | ||
| 3401 | core::core_arch::s390x::vector | vec_msum_u128 | function | ||
| 3402 | core::core_arch::s390x::vector | vec_mul | function | ||
| 3403 | core::core_arch::s390x::vector | vec_mule | function | ||
| 3404 | core::core_arch::s390x::vector | vec_mulh | function | ||
| 3405 | core::core_arch::s390x::vector | vec_mulo | function | ||
| 3406 | core::core_arch::s390x::vector | vec_nabs | function | ||
| 3407 | core::core_arch::s390x::vector | vec_nand | function | ||
| 3408 | core::core_arch::s390x::vector | vec_neg | function | ||
| 3409 | core::core_arch::s390x::vector | vec_nmadd | function | ||
| 3410 | core::core_arch::s390x::vector | vec_nmsub | function | ||
| 3411 | core::core_arch::s390x::vector | vec_nor | function | ||
| 3412 | core::core_arch::s390x::vector | vec_or | function | ||
| 3413 | core::core_arch::s390x::vector | vec_orc | function | ||
| 3414 | core::core_arch::s390x::vector | vec_pack | function | ||
| 3415 | core::core_arch::s390x::vector | vec_packs | function | ||
| 3416 | core::core_arch::s390x::vector | vec_packs_cc | function | ||
| 3417 | core::core_arch::s390x::vector | vec_packsu | function | ||
| 3418 | core::core_arch::s390x::vector | vec_packsu_cc | function | ||
| 3419 | core::core_arch::s390x::vector | vec_perm | function | ||
| 3420 | core::core_arch::s390x::vector | vec_popcnt | function | ||
| 3421 | core::core_arch::s390x::vector | vec_promote | function | ||
| 3422 | core::core_arch::s390x::vector | vec_revb | function | ||
| 3423 | core::core_arch::s390x::vector | vec_reve | function | ||
| 3424 | core::core_arch::s390x::vector | vec_rint | function | ||
| 3425 | core::core_arch::s390x::vector | vec_rl | function | ||
| 3426 | core::core_arch::s390x::vector | vec_rli | function | ||
| 3427 | core::core_arch::s390x::vector | vec_round | function | ||
| 3428 | core::core_arch::s390x::vector | vec_round_from_fp32 | function | ||
| 3429 | core::core_arch::s390x::vector | vec_roundc | function | ||
| 3430 | core::core_arch::s390x::vector | vec_roundm | function | ||
| 3431 | core::core_arch::s390x::vector | vec_roundp | function | ||
| 3432 | core::core_arch::s390x::vector | vec_roundz | function | ||
| 3433 | core::core_arch::s390x::vector | vec_search_string_cc | function | ||
| 3434 | core::core_arch::s390x::vector | vec_search_string_until_zero_cc | function | ||
| 3435 | core::core_arch::s390x::vector | vec_sel | function | ||
| 3436 | core::core_arch::s390x::vector | vec_signed | function | ||
| 3437 | core::core_arch::s390x::vector | vec_sl | function | ||
| 3438 | core::core_arch::s390x::vector | vec_slb | function | ||
| 3439 | core::core_arch::s390x::vector | vec_sld | function | ||
| 3440 | core::core_arch::s390x::vector | vec_sldb | function | ||
| 3441 | core::core_arch::s390x::vector | vec_sldw | function | ||
| 3442 | core::core_arch::s390x::vector | vec_sll | function | ||
| 3443 | core::core_arch::s390x::vector | vec_splat | function | ||
| 3444 | core::core_arch::s390x::vector | vec_splat_s16 | function | ||
| 3445 | core::core_arch::s390x::vector | vec_splat_s32 | function | ||
| 3446 | core::core_arch::s390x::vector | vec_splat_s64 | function | ||
| 3447 | core::core_arch::s390x::vector | vec_splat_s8 | function | ||
| 3448 | core::core_arch::s390x::vector | vec_splat_u16 | function | ||
| 3449 | core::core_arch::s390x::vector | vec_splat_u32 | function | ||
| 3450 | core::core_arch::s390x::vector | vec_splat_u64 | function | ||
| 3451 | core::core_arch::s390x::vector | vec_splat_u8 | function | ||
| 3452 | core::core_arch::s390x::vector | vec_splats | function | ||
| 3453 | core::core_arch::s390x::vector | vec_sqrt | function | ||
| 3454 | core::core_arch::s390x::vector | vec_sr | function | ||
| 3455 | core::core_arch::s390x::vector | vec_sra | function | ||
| 3456 | core::core_arch::s390x::vector | vec_srab | function | ||
| 3457 | core::core_arch::s390x::vector | vec_sral | function | ||
| 3458 | core::core_arch::s390x::vector | vec_srb | function | ||
| 3459 | core::core_arch::s390x::vector | vec_srdb | function | ||
| 3460 | core::core_arch::s390x::vector | vec_srl | function | ||
| 3461 | core::core_arch::s390x::vector | vec_store_len | function | ||
| 3462 | core::core_arch::s390x::vector | vec_store_len_r | function | ||
| 3463 | core::core_arch::s390x::vector | vec_sub | function | ||
| 3464 | core::core_arch::s390x::vector | vec_sub_u128 | function | ||
| 3465 | core::core_arch::s390x::vector | vec_subc | function | ||
| 3466 | core::core_arch::s390x::vector | vec_subc_u128 | function | ||
| 3467 | core::core_arch::s390x::vector | vec_sube_u128 | function | ||
| 3468 | core::core_arch::s390x::vector | vec_subec_u128 | function | ||
| 3469 | core::core_arch::s390x::vector | vec_sum2 | function | ||
| 3470 | core::core_arch::s390x::vector | vec_sum4 | function | ||
| 3471 | core::core_arch::s390x::vector | vec_sum_u128 | function | ||
| 3472 | core::core_arch::s390x::vector | vec_test_mask | function | ||
| 3473 | core::core_arch::s390x::vector | vec_trunc | function | ||
| 3474 | core::core_arch::s390x::vector | vec_unpackh | function | ||
| 3475 | core::core_arch::s390x::vector | vec_unpackl | function | ||
| 3476 | core::core_arch::s390x::vector | vec_unsigned | function | ||
| 3477 | core::core_arch::s390x::vector | vec_xl | function | ||
| 3478 | core::core_arch::s390x::vector | vec_xor | function | ||
| 3479 | core::core_arch::s390x::vector | vec_xst | function | ||
| 3480 | core::core_arch::wasm32::atomic | memory_atomic_notify | function | ||
| 3481 | core::core_arch::wasm32::atomic | memory_atomic_wait32 | function | ||
| 3482 | core::core_arch::wasm32::atomic | memory_atomic_wait64 | function | ||
| 3483 | core::core_arch::wasm32::simd128 | i16x8_load_extend_i8x8 | function | ||
| 3484 | core::core_arch::wasm32::simd128 | i16x8_load_extend_u8x8 | function | ||
| 3485 | core::core_arch::wasm32::simd128 | i32x4_load_extend_i16x4 | function | ||
| 3486 | core::core_arch::wasm32::simd128 | i32x4_load_extend_u16x4 | function | ||
| 3487 | core::core_arch::wasm32::simd128 | i64x2_load_extend_i32x2 | function | ||
| 3488 | core::core_arch::wasm32::simd128 | i64x2_load_extend_u32x2 | function | ||
| 3489 | core::core_arch::wasm32::simd128 | v128_load | function | ||
| 3490 | core::core_arch::wasm32::simd128 | v128_load16_lane | function | ||
| 3491 | core::core_arch::wasm32::simd128 | v128_load16_splat | function | ||
| 3492 | core::core_arch::wasm32::simd128 | v128_load32_lane | function | ||
| 3493 | core::core_arch::wasm32::simd128 | v128_load32_splat | function | ||
| 3494 | core::core_arch::wasm32::simd128 | v128_load32_zero | function | ||
| 3495 | core::core_arch::wasm32::simd128 | v128_load64_lane | function | ||
| 3496 | core::core_arch::wasm32::simd128 | v128_load64_splat | function | ||
| 3497 | core::core_arch::wasm32::simd128 | v128_load64_zero | function | ||
| 3498 | core::core_arch::wasm32::simd128 | v128_load8_lane | function | ||
| 3499 | core::core_arch::wasm32::simd128 | v128_load8_splat | function | ||
| 3500 | core::core_arch::wasm32::simd128 | v128_store | function | ||
| 3501 | core::core_arch::wasm32::simd128 | v128_store16_lane | function | ||
| 3502 | core::core_arch::wasm32::simd128 | v128_store32_lane | function | ||
| 3503 | core::core_arch::wasm32::simd128 | v128_store64_lane | function | ||
| 3504 | core::core_arch::wasm32::simd128 | v128_store8_lane | function | ||
| 3505 | core::core_arch::x86::avx | _mm256_lddqu_si256 | function | ||
| 3506 | core::core_arch::x86::avx | _mm256_load_pd | function | ||
| 3507 | core::core_arch::x86::avx | _mm256_load_ps | function | ||
| 3508 | core::core_arch::x86::avx | _mm256_load_si256 | function | ||
| 3509 | core::core_arch::x86::avx | _mm256_loadu2_m128 | function | ||
| 3510 | core::core_arch::x86::avx | _mm256_loadu2_m128d | function | ||
| 3511 | core::core_arch::x86::avx | _mm256_loadu2_m128i | function | ||
| 3512 | core::core_arch::x86::avx | _mm256_loadu_pd | function | ||
| 3513 | core::core_arch::x86::avx | _mm256_loadu_ps | function | ||
| 3514 | core::core_arch::x86::avx | _mm256_loadu_si256 | function | ||
| 3515 | core::core_arch::x86::avx | _mm256_maskload_pd | function | ||
| 3516 | core::core_arch::x86::avx | _mm256_maskload_ps | function | ||
| 3517 | core::core_arch::x86::avx | _mm256_maskstore_pd | function | ||
| 3518 | core::core_arch::x86::avx | _mm256_maskstore_ps | function | ||
| 3519 | core::core_arch::x86::avx | _mm256_store_pd | function | ||
| 3520 | core::core_arch::x86::avx | _mm256_store_ps | function | ||
| 3521 | core::core_arch::x86::avx | _mm256_store_si256 | function | ||
| 3522 | core::core_arch::x86::avx | _mm256_storeu2_m128 | function | ||
| 3523 | core::core_arch::x86::avx | _mm256_storeu2_m128d | function | ||
| 3524 | core::core_arch::x86::avx | _mm256_storeu2_m128i | function | ||
| 3525 | core::core_arch::x86::avx | _mm256_storeu_pd | function | ||
| 3526 | core::core_arch::x86::avx | _mm256_storeu_ps | function | ||
| 3527 | core::core_arch::x86::avx | _mm256_storeu_si256 | function | ||
| 3528 | core::core_arch::x86::avx | _mm256_stream_pd | function | 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. See [`_mm_sfence`] for details. | |
| 3529 | core::core_arch::x86::avx | _mm256_stream_ps | function | 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. See [`_mm_sfence`] for details. | |
| 3530 | core::core_arch::x86::avx | _mm256_stream_si256 | function | 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. See [`_mm_sfence`] for details. | |
| 3531 | core::core_arch::x86::avx | _mm_maskload_pd | function | ||
| 3532 | core::core_arch::x86::avx | _mm_maskload_ps | function | ||
| 3533 | core::core_arch::x86::avx | _mm_maskstore_pd | function | ||
| 3534 | core::core_arch::x86::avx | _mm_maskstore_ps | function | ||
| 3535 | core::core_arch::x86::avx2 | _mm256_i32gather_epi32 | function | ||
| 3536 | core::core_arch::x86::avx2 | _mm256_i32gather_epi64 | function | ||
| 3537 | core::core_arch::x86::avx2 | _mm256_i32gather_pd | function | ||
| 3538 | core::core_arch::x86::avx2 | _mm256_i32gather_ps | function | ||
| 3539 | core::core_arch::x86::avx2 | _mm256_i64gather_epi32 | function | ||
| 3540 | core::core_arch::x86::avx2 | _mm256_i64gather_epi64 | function | ||
| 3541 | core::core_arch::x86::avx2 | _mm256_i64gather_pd | function | ||
| 3542 | core::core_arch::x86::avx2 | _mm256_i64gather_ps | function | ||
| 3543 | core::core_arch::x86::avx2 | _mm256_mask_i32gather_epi32 | function | ||
| 3544 | core::core_arch::x86::avx2 | _mm256_mask_i32gather_epi64 | function | ||
| 3545 | core::core_arch::x86::avx2 | _mm256_mask_i32gather_pd | function | ||
| 3546 | core::core_arch::x86::avx2 | _mm256_mask_i32gather_ps | function | ||
| 3547 | core::core_arch::x86::avx2 | _mm256_mask_i64gather_epi32 | function | ||
| 3548 | core::core_arch::x86::avx2 | _mm256_mask_i64gather_epi64 | function | ||
| 3549 | core::core_arch::x86::avx2 | _mm256_mask_i64gather_pd | function | ||
| 3550 | core::core_arch::x86::avx2 | _mm256_mask_i64gather_ps | function | ||
| 3551 | core::core_arch::x86::avx2 | _mm256_maskload_epi32 | function | ||
| 3552 | core::core_arch::x86::avx2 | _mm256_maskload_epi64 | function | ||
| 3553 | core::core_arch::x86::avx2 | _mm256_maskstore_epi32 | function | ||
| 3554 | core::core_arch::x86::avx2 | _mm256_maskstore_epi64 | function | ||
| 3555 | core::core_arch::x86::avx2 | _mm256_stream_load_si256 | function | ||
| 3556 | core::core_arch::x86::avx2 | _mm_i32gather_epi32 | function | ||
| 3557 | core::core_arch::x86::avx2 | _mm_i32gather_epi64 | function | ||
| 3558 | core::core_arch::x86::avx2 | _mm_i32gather_pd | function | ||
| 3559 | core::core_arch::x86::avx2 | _mm_i32gather_ps | function | ||
| 3560 | core::core_arch::x86::avx2 | _mm_i64gather_epi32 | function | ||
| 3561 | core::core_arch::x86::avx2 | _mm_i64gather_epi64 | function | ||
| 3562 | core::core_arch::x86::avx2 | _mm_i64gather_pd | function | ||
| 3563 | core::core_arch::x86::avx2 | _mm_i64gather_ps | function | ||
| 3564 | core::core_arch::x86::avx2 | _mm_mask_i32gather_epi32 | function | ||
| 3565 | core::core_arch::x86::avx2 | _mm_mask_i32gather_epi64 | function | ||
| 3566 | core::core_arch::x86::avx2 | _mm_mask_i32gather_pd | function | ||
| 3567 | core::core_arch::x86::avx2 | _mm_mask_i32gather_ps | function | ||
| 3568 | core::core_arch::x86::avx2 | _mm_mask_i64gather_epi32 | function | ||
| 3569 | core::core_arch::x86::avx2 | _mm_mask_i64gather_epi64 | function | ||
| 3570 | core::core_arch::x86::avx2 | _mm_mask_i64gather_pd | function | ||
| 3571 | core::core_arch::x86::avx2 | _mm_mask_i64gather_ps | function | ||
| 3572 | core::core_arch::x86::avx2 | _mm_maskload_epi32 | function | ||
| 3573 | core::core_arch::x86::avx2 | _mm_maskload_epi64 | function | ||
| 3574 | core::core_arch::x86::avx2 | _mm_maskstore_epi32 | function | ||
| 3575 | core::core_arch::x86::avx2 | _mm_maskstore_epi64 | function | ||
| 3576 | core::core_arch::x86::avx512bw | _kortest_mask32_u8 | function | ||
| 3577 | core::core_arch::x86::avx512bw | _kortest_mask64_u8 | function | ||
| 3578 | core::core_arch::x86::avx512bw | _ktest_mask32_u8 | function | ||
| 3579 | core::core_arch::x86::avx512bw | _ktest_mask64_u8 | function | ||
| 3580 | core::core_arch::x86::avx512bw | _load_mask32 | function | ||
| 3581 | core::core_arch::x86::avx512bw | _load_mask64 | function | ||
| 3582 | core::core_arch::x86::avx512bw | _mm256_loadu_epi16 | function | ||
| 3583 | core::core_arch::x86::avx512bw | _mm256_loadu_epi8 | function | ||
| 3584 | core::core_arch::x86::avx512bw | _mm256_mask_cvtepi16_storeu_epi8 | function | ||
| 3585 | core::core_arch::x86::avx512bw | _mm256_mask_cvtsepi16_storeu_epi8 | function | ||
| 3586 | core::core_arch::x86::avx512bw | _mm256_mask_cvtusepi16_storeu_epi8 | function | ||
| 3587 | core::core_arch::x86::avx512bw | _mm256_mask_loadu_epi16 | function | ||
| 3588 | core::core_arch::x86::avx512bw | _mm256_mask_loadu_epi8 | function | ||
| 3589 | core::core_arch::x86::avx512bw | _mm256_mask_storeu_epi16 | function | ||
| 3590 | core::core_arch::x86::avx512bw | _mm256_mask_storeu_epi8 | function | ||
| 3591 | core::core_arch::x86::avx512bw | _mm256_maskz_loadu_epi16 | function | ||
| 3592 | core::core_arch::x86::avx512bw | _mm256_maskz_loadu_epi8 | function | ||
| 3593 | core::core_arch::x86::avx512bw | _mm256_storeu_epi16 | function | ||
| 3594 | core::core_arch::x86::avx512bw | _mm256_storeu_epi8 | function | ||
| 3595 | core::core_arch::x86::avx512bw | _mm512_loadu_epi16 | function | ||
| 3596 | core::core_arch::x86::avx512bw | _mm512_loadu_epi8 | function | ||
| 3597 | core::core_arch::x86::avx512bw | _mm512_mask_cvtepi16_storeu_epi8 | function | ||
| 3598 | core::core_arch::x86::avx512bw | _mm512_mask_cvtsepi16_storeu_epi8 | function | ||
| 3599 | core::core_arch::x86::avx512bw | _mm512_mask_cvtusepi16_storeu_epi8 | function | ||
| 3600 | core::core_arch::x86::avx512bw | _mm512_mask_loadu_epi16 | function | ||
| 3601 | core::core_arch::x86::avx512bw | _mm512_mask_loadu_epi8 | function | ||
| 3602 | core::core_arch::x86::avx512bw | _mm512_mask_storeu_epi16 | function | ||
| 3603 | core::core_arch::x86::avx512bw | _mm512_mask_storeu_epi8 | function | ||
| 3604 | core::core_arch::x86::avx512bw | _mm512_maskz_loadu_epi16 | function | ||
| 3605 | core::core_arch::x86::avx512bw | _mm512_maskz_loadu_epi8 | function | ||
| 3606 | core::core_arch::x86::avx512bw | _mm512_storeu_epi16 | function | ||
| 3607 | core::core_arch::x86::avx512bw | _mm512_storeu_epi8 | function | ||
| 3608 | core::core_arch::x86::avx512bw | _mm_loadu_epi16 | function | ||
| 3609 | core::core_arch::x86::avx512bw | _mm_loadu_epi8 | function | ||
| 3610 | core::core_arch::x86::avx512bw | _mm_mask_cvtepi16_storeu_epi8 | function | ||
| 3611 | core::core_arch::x86::avx512bw | _mm_mask_cvtsepi16_storeu_epi8 | function | ||
| 3612 | core::core_arch::x86::avx512bw | _mm_mask_cvtusepi16_storeu_epi8 | function | ||
| 3613 | core::core_arch::x86::avx512bw | _mm_mask_loadu_epi16 | function | ||
| 3614 | core::core_arch::x86::avx512bw | _mm_mask_loadu_epi8 | function | ||
| 3615 | core::core_arch::x86::avx512bw | _mm_mask_storeu_epi16 | function | ||
| 3616 | core::core_arch::x86::avx512bw | _mm_mask_storeu_epi8 | function | ||
| 3617 | core::core_arch::x86::avx512bw | _mm_maskz_loadu_epi16 | function | ||
| 3618 | core::core_arch::x86::avx512bw | _mm_maskz_loadu_epi8 | function | ||
| 3619 | core::core_arch::x86::avx512bw | _mm_storeu_epi16 | function | ||
| 3620 | core::core_arch::x86::avx512bw | _mm_storeu_epi8 | function | ||
| 3621 | core::core_arch::x86::avx512bw | _store_mask32 | function | ||
| 3622 | core::core_arch::x86::avx512bw | _store_mask64 | function | ||
| 3623 | core::core_arch::x86::avx512dq | _kortest_mask8_u8 | function | ||
| 3624 | core::core_arch::x86::avx512dq | _ktest_mask16_u8 | function | ||
| 3625 | core::core_arch::x86::avx512dq | _ktest_mask8_u8 | function | ||
| 3626 | core::core_arch::x86::avx512dq | _load_mask8 | function | ||
| 3627 | core::core_arch::x86::avx512dq | _store_mask8 | function | ||
| 3628 | core::core_arch::x86::avx512f | _kortest_mask16_u8 | function | ||
| 3629 | core::core_arch::x86::avx512f | _load_mask16 | function | ||
| 3630 | core::core_arch::x86::avx512f | _mm256_i32scatter_epi32 | function | ||
| 3631 | core::core_arch::x86::avx512f | _mm256_i32scatter_epi64 | function | ||
| 3632 | core::core_arch::x86::avx512f | _mm256_i32scatter_pd | function | ||
| 3633 | core::core_arch::x86::avx512f | _mm256_i32scatter_ps | function | ||
| 3634 | core::core_arch::x86::avx512f | _mm256_i64scatter_epi32 | function | ||
| 3635 | core::core_arch::x86::avx512f | _mm256_i64scatter_epi64 | function | ||
| 3636 | core::core_arch::x86::avx512f | _mm256_i64scatter_pd | function | ||
| 3637 | core::core_arch::x86::avx512f | _mm256_i64scatter_ps | function | ||
| 3638 | core::core_arch::x86::avx512f | _mm256_load_epi32 | function | ||
| 3639 | core::core_arch::x86::avx512f | _mm256_load_epi64 | function | ||
| 3640 | core::core_arch::x86::avx512f | _mm256_loadu_epi32 | function | ||
| 3641 | core::core_arch::x86::avx512f | _mm256_loadu_epi64 | function | ||
| 3642 | core::core_arch::x86::avx512f | _mm256_mask_compressstoreu_epi32 | function | ||
| 3643 | core::core_arch::x86::avx512f | _mm256_mask_compressstoreu_epi64 | function | ||
| 3644 | core::core_arch::x86::avx512f | _mm256_mask_compressstoreu_pd | function | ||
| 3645 | core::core_arch::x86::avx512f | _mm256_mask_compressstoreu_ps | function | ||
| 3646 | core::core_arch::x86::avx512f | _mm256_mask_cvtepi32_storeu_epi16 | function | ||
| 3647 | core::core_arch::x86::avx512f | _mm256_mask_cvtepi32_storeu_epi8 | function | ||
| 3648 | core::core_arch::x86::avx512f | _mm256_mask_cvtepi64_storeu_epi16 | function | ||
| 3649 | core::core_arch::x86::avx512f | _mm256_mask_cvtepi64_storeu_epi32 | function | ||
| 3650 | core::core_arch::x86::avx512f | _mm256_mask_cvtepi64_storeu_epi8 | function | ||
| 3651 | core::core_arch::x86::avx512f | _mm256_mask_cvtsepi32_storeu_epi16 | function | ||
| 3652 | core::core_arch::x86::avx512f | _mm256_mask_cvtsepi32_storeu_epi8 | function | ||
| 3653 | core::core_arch::x86::avx512f | _mm256_mask_cvtsepi64_storeu_epi16 | function | ||
| 3654 | core::core_arch::x86::avx512f | _mm256_mask_cvtsepi64_storeu_epi32 | function | ||
| 3655 | core::core_arch::x86::avx512f | _mm256_mask_cvtsepi64_storeu_epi8 | function | ||
| 3656 | core::core_arch::x86::avx512f | _mm256_mask_cvtusepi32_storeu_epi16 | function | ||
| 3657 | core::core_arch::x86::avx512f | _mm256_mask_cvtusepi32_storeu_epi8 | function | ||
| 3658 | core::core_arch::x86::avx512f | _mm256_mask_cvtusepi64_storeu_epi16 | function | ||
| 3659 | core::core_arch::x86::avx512f | _mm256_mask_cvtusepi64_storeu_epi32 | function | ||
| 3660 | core::core_arch::x86::avx512f | _mm256_mask_cvtusepi64_storeu_epi8 | function | ||
| 3661 | core::core_arch::x86::avx512f | _mm256_mask_expandloadu_epi32 | function | ||
| 3662 | core::core_arch::x86::avx512f | _mm256_mask_expandloadu_epi64 | function | ||
| 3663 | core::core_arch::x86::avx512f | _mm256_mask_expandloadu_pd | function | ||
| 3664 | core::core_arch::x86::avx512f | _mm256_mask_expandloadu_ps | function | ||
| 3665 | core::core_arch::x86::avx512f | _mm256_mask_i32scatter_epi32 | function | ||
| 3666 | core::core_arch::x86::avx512f | _mm256_mask_i32scatter_epi64 | function | ||
| 3667 | core::core_arch::x86::avx512f | _mm256_mask_i32scatter_pd | function | ||
| 3668 | core::core_arch::x86::avx512f | _mm256_mask_i32scatter_ps | function | ||
| 3669 | core::core_arch::x86::avx512f | _mm256_mask_i64scatter_epi32 | function | ||
| 3670 | core::core_arch::x86::avx512f | _mm256_mask_i64scatter_epi64 | function | ||
| 3671 | core::core_arch::x86::avx512f | _mm256_mask_i64scatter_pd | function | ||
| 3672 | core::core_arch::x86::avx512f | _mm256_mask_i64scatter_ps | function | ||
| 3673 | core::core_arch::x86::avx512f | _mm256_mask_load_epi32 | function | ||
| 3674 | core::core_arch::x86::avx512f | _mm256_mask_load_epi64 | function | ||
| 3675 | core::core_arch::x86::avx512f | _mm256_mask_load_pd | function | ||
| 3676 | core::core_arch::x86::avx512f | _mm256_mask_load_ps | function | ||
| 3677 | core::core_arch::x86::avx512f | _mm256_mask_loadu_epi32 | function | ||
| 3678 | core::core_arch::x86::avx512f | _mm256_mask_loadu_epi64 | function | ||
| 3679 | core::core_arch::x86::avx512f | _mm256_mask_loadu_pd | function | ||
| 3680 | core::core_arch::x86::avx512f | _mm256_mask_loadu_ps | function | ||
| 3681 | core::core_arch::x86::avx512f | _mm256_mask_store_epi32 | function | ||
| 3682 | core::core_arch::x86::avx512f | _mm256_mask_store_epi64 | function | ||
| 3683 | core::core_arch::x86::avx512f | _mm256_mask_store_pd | function | ||
| 3684 | core::core_arch::x86::avx512f | _mm256_mask_store_ps | function | ||
| 3685 | core::core_arch::x86::avx512f | _mm256_mask_storeu_epi32 | function | ||
| 3686 | core::core_arch::x86::avx512f | _mm256_mask_storeu_epi64 | function | ||
| 3687 | core::core_arch::x86::avx512f | _mm256_mask_storeu_pd | function | ||
| 3688 | core::core_arch::x86::avx512f | _mm256_mask_storeu_ps | function | ||
| 3689 | core::core_arch::x86::avx512f | _mm256_maskz_expandloadu_epi32 | function | ||
| 3690 | core::core_arch::x86::avx512f | _mm256_maskz_expandloadu_epi64 | function | ||
| 3691 | core::core_arch::x86::avx512f | _mm256_maskz_expandloadu_pd | function | ||
| 3692 | core::core_arch::x86::avx512f | _mm256_maskz_expandloadu_ps | function | ||
| 3693 | core::core_arch::x86::avx512f | _mm256_maskz_load_epi32 | function | ||
| 3694 | core::core_arch::x86::avx512f | _mm256_maskz_load_epi64 | function | ||
| 3695 | core::core_arch::x86::avx512f | _mm256_maskz_load_pd | function | ||
| 3696 | core::core_arch::x86::avx512f | _mm256_maskz_load_ps | function | ||
| 3697 | core::core_arch::x86::avx512f | _mm256_maskz_loadu_epi32 | function | ||
| 3698 | core::core_arch::x86::avx512f | _mm256_maskz_loadu_epi64 | function | ||
| 3699 | core::core_arch::x86::avx512f | _mm256_maskz_loadu_pd | function | ||
| 3700 | core::core_arch::x86::avx512f | _mm256_maskz_loadu_ps | function | ||
| 3701 | core::core_arch::x86::avx512f | _mm256_mmask_i32gather_epi32 | function | ||
| 3702 | core::core_arch::x86::avx512f | _mm256_mmask_i32gather_epi64 | function | ||
| 3703 | core::core_arch::x86::avx512f | _mm256_mmask_i32gather_pd | function | ||
| 3704 | core::core_arch::x86::avx512f | _mm256_mmask_i32gather_ps | function | ||
| 3705 | core::core_arch::x86::avx512f | _mm256_mmask_i64gather_epi32 | function | ||
| 3706 | core::core_arch::x86::avx512f | _mm256_mmask_i64gather_epi64 | function | ||
| 3707 | core::core_arch::x86::avx512f | _mm256_mmask_i64gather_pd | function | ||
| 3708 | core::core_arch::x86::avx512f | _mm256_mmask_i64gather_ps | function | ||
| 3709 | core::core_arch::x86::avx512f | _mm256_store_epi32 | function | ||
| 3710 | core::core_arch::x86::avx512f | _mm256_store_epi64 | function | ||
| 3711 | core::core_arch::x86::avx512f | _mm256_storeu_epi32 | function | ||
| 3712 | core::core_arch::x86::avx512f | _mm256_storeu_epi64 | function | ||
| 3713 | core::core_arch::x86::avx512f | _mm512_i32gather_epi32 | function | ||
| 3714 | core::core_arch::x86::avx512f | _mm512_i32gather_epi64 | function | ||
| 3715 | core::core_arch::x86::avx512f | _mm512_i32gather_pd | function | ||
| 3716 | core::core_arch::x86::avx512f | _mm512_i32gather_ps | function | ||
| 3717 | core::core_arch::x86::avx512f | _mm512_i32logather_epi64 | function | ||
| 3718 | core::core_arch::x86::avx512f | _mm512_i32logather_pd | function | ||
| 3719 | core::core_arch::x86::avx512f | _mm512_i32loscatter_epi64 | function | ||
| 3720 | core::core_arch::x86::avx512f | _mm512_i32loscatter_pd | function | ||
| 3721 | core::core_arch::x86::avx512f | _mm512_i32scatter_epi32 | function | ||
| 3722 | core::core_arch::x86::avx512f | _mm512_i32scatter_epi64 | function | ||
| 3723 | core::core_arch::x86::avx512f | _mm512_i32scatter_pd | function | ||
| 3724 | core::core_arch::x86::avx512f | _mm512_i32scatter_ps | function | ||
| 3725 | core::core_arch::x86::avx512f | _mm512_i64gather_epi32 | function | ||
| 3726 | core::core_arch::x86::avx512f | _mm512_i64gather_epi64 | function | ||
| 3727 | core::core_arch::x86::avx512f | _mm512_i64gather_pd | function | ||
| 3728 | core::core_arch::x86::avx512f | _mm512_i64gather_ps | function | ||
| 3729 | core::core_arch::x86::avx512f | _mm512_i64scatter_epi32 | function | ||
| 3730 | core::core_arch::x86::avx512f | _mm512_i64scatter_epi64 | function | ||
| 3731 | core::core_arch::x86::avx512f | _mm512_i64scatter_pd | function | ||
| 3732 | core::core_arch::x86::avx512f | _mm512_i64scatter_ps | function | ||
| 3733 | core::core_arch::x86::avx512f | _mm512_load_epi32 | function | ||
| 3734 | core::core_arch::x86::avx512f | _mm512_load_epi64 | function | ||
| 3735 | core::core_arch::x86::avx512f | _mm512_load_pd | function | ||
| 3736 | core::core_arch::x86::avx512f | _mm512_load_ps | function | ||
| 3737 | core::core_arch::x86::avx512f | _mm512_load_si512 | function | ||
| 3738 | core::core_arch::x86::avx512f | _mm512_loadu_epi32 | function | ||
| 3739 | core::core_arch::x86::avx512f | _mm512_loadu_epi64 | function | ||
| 3740 | core::core_arch::x86::avx512f | _mm512_loadu_pd | function | ||
| 3741 | core::core_arch::x86::avx512f | _mm512_loadu_ps | function | ||
| 3742 | core::core_arch::x86::avx512f | _mm512_loadu_si512 | function | ||
| 3743 | core::core_arch::x86::avx512f | _mm512_mask_compressstoreu_epi32 | function | ||
| 3744 | core::core_arch::x86::avx512f | _mm512_mask_compressstoreu_epi64 | function | ||
| 3745 | core::core_arch::x86::avx512f | _mm512_mask_compressstoreu_pd | function | ||
| 3746 | core::core_arch::x86::avx512f | _mm512_mask_compressstoreu_ps | function | ||
| 3747 | core::core_arch::x86::avx512f | _mm512_mask_cvtepi32_storeu_epi16 | function | ||
| 3748 | core::core_arch::x86::avx512f | _mm512_mask_cvtepi32_storeu_epi8 | function | ||
| 3749 | core::core_arch::x86::avx512f | _mm512_mask_cvtepi64_storeu_epi16 | function | ||
| 3750 | core::core_arch::x86::avx512f | _mm512_mask_cvtepi64_storeu_epi32 | function | ||
| 3751 | core::core_arch::x86::avx512f | _mm512_mask_cvtepi64_storeu_epi8 | function | ||
| 3752 | core::core_arch::x86::avx512f | _mm512_mask_cvtsepi32_storeu_epi16 | function | ||
| 3753 | core::core_arch::x86::avx512f | _mm512_mask_cvtsepi32_storeu_epi8 | function | ||
| 3754 | core::core_arch::x86::avx512f | _mm512_mask_cvtsepi64_storeu_epi16 | function | ||
| 3755 | core::core_arch::x86::avx512f | _mm512_mask_cvtsepi64_storeu_epi32 | function | ||
| 3756 | core::core_arch::x86::avx512f | _mm512_mask_cvtsepi64_storeu_epi8 | function | ||
| 3757 | core::core_arch::x86::avx512f | _mm512_mask_cvtusepi32_storeu_epi16 | function | ||
| 3758 | core::core_arch::x86::avx512f | _mm512_mask_cvtusepi32_storeu_epi8 | function | ||
| 3759 | core::core_arch::x86::avx512f | _mm512_mask_cvtusepi64_storeu_epi16 | function | ||
| 3760 | core::core_arch::x86::avx512f | _mm512_mask_cvtusepi64_storeu_epi32 | function | ||
| 3761 | core::core_arch::x86::avx512f | _mm512_mask_cvtusepi64_storeu_epi8 | function | ||
| 3762 | core::core_arch::x86::avx512f | _mm512_mask_expandloadu_epi32 | function | ||
| 3763 | core::core_arch::x86::avx512f | _mm512_mask_expandloadu_epi64 | function | ||
| 3764 | core::core_arch::x86::avx512f | _mm512_mask_expandloadu_pd | function | ||
| 3765 | core::core_arch::x86::avx512f | _mm512_mask_expandloadu_ps | function | ||
| 3766 | core::core_arch::x86::avx512f | _mm512_mask_i32gather_epi32 | function | ||
| 3767 | core::core_arch::x86::avx512f | _mm512_mask_i32gather_epi64 | function | ||
| 3768 | core::core_arch::x86::avx512f | _mm512_mask_i32gather_pd | function | ||
| 3769 | core::core_arch::x86::avx512f | _mm512_mask_i32gather_ps | function | ||
| 3770 | core::core_arch::x86::avx512f | _mm512_mask_i32logather_epi64 | function | ||
| 3771 | core::core_arch::x86::avx512f | _mm512_mask_i32logather_pd | function | ||
| 3772 | core::core_arch::x86::avx512f | _mm512_mask_i32loscatter_epi64 | function | ||
| 3773 | core::core_arch::x86::avx512f | _mm512_mask_i32loscatter_pd | function | ||
| 3774 | core::core_arch::x86::avx512f | _mm512_mask_i32scatter_epi32 | function | ||
| 3775 | core::core_arch::x86::avx512f | _mm512_mask_i32scatter_epi64 | function | ||
| 3776 | core::core_arch::x86::avx512f | _mm512_mask_i32scatter_pd | function | ||
| 3777 | core::core_arch::x86::avx512f | _mm512_mask_i32scatter_ps | function | ||
| 3778 | core::core_arch::x86::avx512f | _mm512_mask_i64gather_epi32 | function | ||
| 3779 | core::core_arch::x86::avx512f | _mm512_mask_i64gather_epi64 | function | ||
| 3780 | core::core_arch::x86::avx512f | _mm512_mask_i64gather_pd | function | ||
| 3781 | core::core_arch::x86::avx512f | _mm512_mask_i64gather_ps | function | ||
| 3782 | core::core_arch::x86::avx512f | _mm512_mask_i64scatter_epi32 | function | ||
| 3783 | core::core_arch::x86::avx512f | _mm512_mask_i64scatter_epi64 | function | ||
| 3784 | core::core_arch::x86::avx512f | _mm512_mask_i64scatter_pd | function | ||
| 3785 | core::core_arch::x86::avx512f | _mm512_mask_i64scatter_ps | function | ||
| 3786 | core::core_arch::x86::avx512f | _mm512_mask_load_epi32 | function | ||
| 3787 | core::core_arch::x86::avx512f | _mm512_mask_load_epi64 | function | ||
| 3788 | core::core_arch::x86::avx512f | _mm512_mask_load_pd | function | ||
| 3789 | core::core_arch::x86::avx512f | _mm512_mask_load_ps | function | ||
| 3790 | core::core_arch::x86::avx512f | _mm512_mask_loadu_epi32 | function | ||
| 3791 | core::core_arch::x86::avx512f | _mm512_mask_loadu_epi64 | function | ||
| 3792 | core::core_arch::x86::avx512f | _mm512_mask_loadu_pd | function | ||
| 3793 | core::core_arch::x86::avx512f | _mm512_mask_loadu_ps | function | ||
| 3794 | core::core_arch::x86::avx512f | _mm512_mask_store_epi32 | function | ||
| 3795 | core::core_arch::x86::avx512f | _mm512_mask_store_epi64 | function | ||
| 3796 | core::core_arch::x86::avx512f | _mm512_mask_store_pd | function | ||
| 3797 | core::core_arch::x86::avx512f | _mm512_mask_store_ps | function | ||
| 3798 | core::core_arch::x86::avx512f | _mm512_mask_storeu_epi32 | function | ||
| 3799 | core::core_arch::x86::avx512f | _mm512_mask_storeu_epi64 | function | ||
| 3800 | core::core_arch::x86::avx512f | _mm512_mask_storeu_pd | function | ||
| 3801 | core::core_arch::x86::avx512f | _mm512_mask_storeu_ps | function | ||
| 3802 | core::core_arch::x86::avx512f | _mm512_maskz_expandloadu_epi32 | function | ||
| 3803 | core::core_arch::x86::avx512f | _mm512_maskz_expandloadu_epi64 | function | ||
| 3804 | core::core_arch::x86::avx512f | _mm512_maskz_expandloadu_pd | function | ||
| 3805 | core::core_arch::x86::avx512f | _mm512_maskz_expandloadu_ps | function | ||
| 3806 | core::core_arch::x86::avx512f | _mm512_maskz_load_epi32 | function | ||
| 3807 | core::core_arch::x86::avx512f | _mm512_maskz_load_epi64 | function | ||
| 3808 | core::core_arch::x86::avx512f | _mm512_maskz_load_pd | function | ||
| 3809 | core::core_arch::x86::avx512f | _mm512_maskz_load_ps | function | ||
| 3810 | core::core_arch::x86::avx512f | _mm512_maskz_loadu_epi32 | function | ||
| 3811 | core::core_arch::x86::avx512f | _mm512_maskz_loadu_epi64 | function | ||
| 3812 | core::core_arch::x86::avx512f | _mm512_maskz_loadu_pd | function | ||
| 3813 | core::core_arch::x86::avx512f | _mm512_maskz_loadu_ps | function | ||
| 3814 | core::core_arch::x86::avx512f | _mm512_store_epi32 | function | ||
| 3815 | core::core_arch::x86::avx512f | _mm512_store_epi64 | function | ||
| 3816 | core::core_arch::x86::avx512f | _mm512_store_pd | function | ||
| 3817 | core::core_arch::x86::avx512f | _mm512_store_ps | function | ||
| 3818 | core::core_arch::x86::avx512f | _mm512_store_si512 | function | ||
| 3819 | core::core_arch::x86::avx512f | _mm512_storeu_epi32 | function | ||
| 3820 | core::core_arch::x86::avx512f | _mm512_storeu_epi64 | function | ||
| 3821 | core::core_arch::x86::avx512f | _mm512_storeu_pd | function | ||
| 3822 | core::core_arch::x86::avx512f | _mm512_storeu_ps | function | ||
| 3823 | core::core_arch::x86::avx512f | _mm512_storeu_si512 | function | ||
| 3824 | core::core_arch::x86::avx512f | _mm512_stream_load_si512 | function | ||
| 3825 | core::core_arch::x86::avx512f | _mm512_stream_pd | function | 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. See [`_mm_sfence`] for details. | |
| 3826 | core::core_arch::x86::avx512f | _mm512_stream_ps | function | 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. See [`_mm_sfence`] for details. | |
| 3827 | core::core_arch::x86::avx512f | _mm512_stream_si512 | function | 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. See [`_mm_sfence`] for details. | |
| 3828 | core::core_arch::x86::avx512f | _mm_i32scatter_epi32 | function | ||
| 3829 | core::core_arch::x86::avx512f | _mm_i32scatter_epi64 | function | ||
| 3830 | core::core_arch::x86::avx512f | _mm_i32scatter_pd | function | ||
| 3831 | core::core_arch::x86::avx512f | _mm_i32scatter_ps | function | ||
| 3832 | core::core_arch::x86::avx512f | _mm_i64scatter_epi32 | function | ||
| 3833 | core::core_arch::x86::avx512f | _mm_i64scatter_epi64 | function | ||
| 3834 | core::core_arch::x86::avx512f | _mm_i64scatter_pd | function | ||
| 3835 | core::core_arch::x86::avx512f | _mm_i64scatter_ps | function | ||
| 3836 | core::core_arch::x86::avx512f | _mm_load_epi32 | function | ||
| 3837 | core::core_arch::x86::avx512f | _mm_load_epi64 | function | ||
| 3838 | core::core_arch::x86::avx512f | _mm_loadu_epi32 | function | ||
| 3839 | core::core_arch::x86::avx512f | _mm_loadu_epi64 | function | ||
| 3840 | core::core_arch::x86::avx512f | _mm_mask_compressstoreu_epi32 | function | ||
| 3841 | core::core_arch::x86::avx512f | _mm_mask_compressstoreu_epi64 | function | ||
| 3842 | core::core_arch::x86::avx512f | _mm_mask_compressstoreu_pd | function | ||
| 3843 | core::core_arch::x86::avx512f | _mm_mask_compressstoreu_ps | function | ||
| 3844 | core::core_arch::x86::avx512f | _mm_mask_cvtepi32_storeu_epi16 | function | ||
| 3845 | core::core_arch::x86::avx512f | _mm_mask_cvtepi32_storeu_epi8 | function | ||
| 3846 | core::core_arch::x86::avx512f | _mm_mask_cvtepi64_storeu_epi16 | function | ||
| 3847 | core::core_arch::x86::avx512f | _mm_mask_cvtepi64_storeu_epi32 | function | ||
| 3848 | core::core_arch::x86::avx512f | _mm_mask_cvtepi64_storeu_epi8 | function | ||
| 3849 | core::core_arch::x86::avx512f | _mm_mask_cvtsepi32_storeu_epi16 | function | ||
| 3850 | core::core_arch::x86::avx512f | _mm_mask_cvtsepi32_storeu_epi8 | function | ||
| 3851 | core::core_arch::x86::avx512f | _mm_mask_cvtsepi64_storeu_epi16 | function | ||
| 3852 | core::core_arch::x86::avx512f | _mm_mask_cvtsepi64_storeu_epi32 | function | ||
| 3853 | core::core_arch::x86::avx512f | _mm_mask_cvtsepi64_storeu_epi8 | function | ||
| 3854 | core::core_arch::x86::avx512f | _mm_mask_cvtusepi32_storeu_epi16 | function | ||
| 3855 | core::core_arch::x86::avx512f | _mm_mask_cvtusepi32_storeu_epi8 | function | ||
| 3856 | core::core_arch::x86::avx512f | _mm_mask_cvtusepi64_storeu_epi16 | function | ||
| 3857 | core::core_arch::x86::avx512f | _mm_mask_cvtusepi64_storeu_epi32 | function | ||
| 3858 | core::core_arch::x86::avx512f | _mm_mask_cvtusepi64_storeu_epi8 | function | ||
| 3859 | core::core_arch::x86::avx512f | _mm_mask_expandloadu_epi32 | function | ||
| 3860 | core::core_arch::x86::avx512f | _mm_mask_expandloadu_epi64 | function | ||
| 3861 | core::core_arch::x86::avx512f | _mm_mask_expandloadu_pd | function | ||
| 3862 | core::core_arch::x86::avx512f | _mm_mask_expandloadu_ps | function | ||
| 3863 | core::core_arch::x86::avx512f | _mm_mask_i32scatter_epi32 | function | ||
| 3864 | core::core_arch::x86::avx512f | _mm_mask_i32scatter_epi64 | function | ||
| 3865 | core::core_arch::x86::avx512f | _mm_mask_i32scatter_pd | function | ||
| 3866 | core::core_arch::x86::avx512f | _mm_mask_i32scatter_ps | function | ||
| 3867 | core::core_arch::x86::avx512f | _mm_mask_i64scatter_epi32 | function | ||
| 3868 | core::core_arch::x86::avx512f | _mm_mask_i64scatter_epi64 | function | ||
| 3869 | core::core_arch::x86::avx512f | _mm_mask_i64scatter_pd | function | ||
| 3870 | core::core_arch::x86::avx512f | _mm_mask_i64scatter_ps | function | ||
| 3871 | core::core_arch::x86::avx512f | _mm_mask_load_epi32 | function | ||
| 3872 | core::core_arch::x86::avx512f | _mm_mask_load_epi64 | function | ||
| 3873 | core::core_arch::x86::avx512f | _mm_mask_load_pd | function | ||
| 3874 | core::core_arch::x86::avx512f | _mm_mask_load_ps | function | ||
| 3875 | core::core_arch::x86::avx512f | _mm_mask_load_sd | function | ||
| 3876 | core::core_arch::x86::avx512f | _mm_mask_load_ss | function | ||
| 3877 | core::core_arch::x86::avx512f | _mm_mask_loadu_epi32 | function | ||
| 3878 | core::core_arch::x86::avx512f | _mm_mask_loadu_epi64 | function | ||
| 3879 | core::core_arch::x86::avx512f | _mm_mask_loadu_pd | function | ||
| 3880 | core::core_arch::x86::avx512f | _mm_mask_loadu_ps | function | ||
| 3881 | core::core_arch::x86::avx512f | _mm_mask_store_epi32 | function | ||
| 3882 | core::core_arch::x86::avx512f | _mm_mask_store_epi64 | function | ||
| 3883 | core::core_arch::x86::avx512f | _mm_mask_store_pd | function | ||
| 3884 | core::core_arch::x86::avx512f | _mm_mask_store_ps | function | ||
| 3885 | core::core_arch::x86::avx512f | _mm_mask_store_sd | function | ||
| 3886 | core::core_arch::x86::avx512f | _mm_mask_store_ss | function | ||
| 3887 | core::core_arch::x86::avx512f | _mm_mask_storeu_epi32 | function | ||
| 3888 | core::core_arch::x86::avx512f | _mm_mask_storeu_epi64 | function | ||
| 3889 | core::core_arch::x86::avx512f | _mm_mask_storeu_pd | function | ||
| 3890 | core::core_arch::x86::avx512f | _mm_mask_storeu_ps | function | ||
| 3891 | core::core_arch::x86::avx512f | _mm_maskz_expandloadu_epi32 | function | ||
| 3892 | core::core_arch::x86::avx512f | _mm_maskz_expandloadu_epi64 | function | ||
| 3893 | core::core_arch::x86::avx512f | _mm_maskz_expandloadu_pd | function | ||
| 3894 | core::core_arch::x86::avx512f | _mm_maskz_expandloadu_ps | function | ||
| 3895 | core::core_arch::x86::avx512f | _mm_maskz_load_epi32 | function | ||
| 3896 | core::core_arch::x86::avx512f | _mm_maskz_load_epi64 | function | ||
| 3897 | core::core_arch::x86::avx512f | _mm_maskz_load_pd | function | ||
| 3898 | core::core_arch::x86::avx512f | _mm_maskz_load_ps | function | ||
| 3899 | core::core_arch::x86::avx512f | _mm_maskz_load_sd | function | ||
| 3900 | core::core_arch::x86::avx512f | _mm_maskz_load_ss | function | ||
| 3901 | core::core_arch::x86::avx512f | _mm_maskz_loadu_epi32 | function | ||
| 3902 | core::core_arch::x86::avx512f | _mm_maskz_loadu_epi64 | function | ||
| 3903 | core::core_arch::x86::avx512f | _mm_maskz_loadu_pd | function | ||
| 3904 | core::core_arch::x86::avx512f | _mm_maskz_loadu_ps | function | ||
| 3905 | core::core_arch::x86::avx512f | _mm_mmask_i32gather_epi32 | function | ||
| 3906 | core::core_arch::x86::avx512f | _mm_mmask_i32gather_epi64 | function | ||
| 3907 | core::core_arch::x86::avx512f | _mm_mmask_i32gather_pd | function | ||
| 3908 | core::core_arch::x86::avx512f | _mm_mmask_i32gather_ps | function | ||
| 3909 | core::core_arch::x86::avx512f | _mm_mmask_i64gather_epi32 | function | ||
| 3910 | core::core_arch::x86::avx512f | _mm_mmask_i64gather_epi64 | function | ||
| 3911 | core::core_arch::x86::avx512f | _mm_mmask_i64gather_pd | function | ||
| 3912 | core::core_arch::x86::avx512f | _mm_mmask_i64gather_ps | function | ||
| 3913 | core::core_arch::x86::avx512f | _mm_store_epi32 | function | ||
| 3914 | core::core_arch::x86::avx512f | _mm_store_epi64 | function | ||
| 3915 | core::core_arch::x86::avx512f | _mm_storeu_epi32 | function | ||
| 3916 | core::core_arch::x86::avx512f | _mm_storeu_epi64 | function | ||
| 3917 | core::core_arch::x86::avx512f | _store_mask16 | function | ||
| 3918 | core::core_arch::x86::avx512fp16 | _mm256_load_ph | function | ||
| 3919 | core::core_arch::x86::avx512fp16 | _mm256_loadu_ph | function | ||
| 3920 | core::core_arch::x86::avx512fp16 | _mm256_store_ph | function | ||
| 3921 | core::core_arch::x86::avx512fp16 | _mm256_storeu_ph | function | ||
| 3922 | core::core_arch::x86::avx512fp16 | _mm512_load_ph | function | ||
| 3923 | core::core_arch::x86::avx512fp16 | _mm512_loadu_ph | function | ||
| 3924 | core::core_arch::x86::avx512fp16 | _mm512_store_ph | function | ||
| 3925 | core::core_arch::x86::avx512fp16 | _mm512_storeu_ph | function | ||
| 3926 | core::core_arch::x86::avx512fp16 | _mm_load_ph | function | ||
| 3927 | core::core_arch::x86::avx512fp16 | _mm_load_sh | function | ||
| 3928 | core::core_arch::x86::avx512fp16 | _mm_loadu_ph | function | ||
| 3929 | core::core_arch::x86::avx512fp16 | _mm_mask_load_sh | function | ||
| 3930 | core::core_arch::x86::avx512fp16 | _mm_mask_store_sh | function | ||
| 3931 | core::core_arch::x86::avx512fp16 | _mm_maskz_load_sh | function | ||
| 3932 | core::core_arch::x86::avx512fp16 | _mm_store_ph | function | ||
| 3933 | core::core_arch::x86::avx512fp16 | _mm_store_sh | function | ||
| 3934 | core::core_arch::x86::avx512fp16 | _mm_storeu_ph | function | ||
| 3935 | core::core_arch::x86::avx512vbmi2 | _mm256_mask_compressstoreu_epi16 | function | ||
| 3936 | core::core_arch::x86::avx512vbmi2 | _mm256_mask_compressstoreu_epi8 | function | ||
| 3937 | core::core_arch::x86::avx512vbmi2 | _mm256_mask_expandloadu_epi16 | function | ||
| 3938 | core::core_arch::x86::avx512vbmi2 | _mm256_mask_expandloadu_epi8 | function | ||
| 3939 | core::core_arch::x86::avx512vbmi2 | _mm256_maskz_expandloadu_epi16 | function | ||
| 3940 | core::core_arch::x86::avx512vbmi2 | _mm256_maskz_expandloadu_epi8 | function | ||
| 3941 | core::core_arch::x86::avx512vbmi2 | _mm512_mask_compressstoreu_epi16 | function | ||
| 3942 | core::core_arch::x86::avx512vbmi2 | _mm512_mask_compressstoreu_epi8 | function | ||
| 3943 | core::core_arch::x86::avx512vbmi2 | _mm512_mask_expandloadu_epi16 | function | ||
| 3944 | core::core_arch::x86::avx512vbmi2 | _mm512_mask_expandloadu_epi8 | function | ||
| 3945 | core::core_arch::x86::avx512vbmi2 | _mm512_maskz_expandloadu_epi16 | function | ||
| 3946 | core::core_arch::x86::avx512vbmi2 | _mm512_maskz_expandloadu_epi8 | function | ||
| 3947 | core::core_arch::x86::avx512vbmi2 | _mm_mask_compressstoreu_epi16 | function | ||
| 3948 | core::core_arch::x86::avx512vbmi2 | _mm_mask_compressstoreu_epi8 | function | ||
| 3949 | core::core_arch::x86::avx512vbmi2 | _mm_mask_expandloadu_epi16 | function | ||
| 3950 | core::core_arch::x86::avx512vbmi2 | _mm_mask_expandloadu_epi8 | function | ||
| 3951 | core::core_arch::x86::avx512vbmi2 | _mm_maskz_expandloadu_epi16 | function | ||
| 3952 | core::core_arch::x86::avx512vbmi2 | _mm_maskz_expandloadu_epi8 | function | ||
| 3953 | core::core_arch::x86::avxneconvert | _mm256_bcstnebf16_ps | function | ||
| 3954 | core::core_arch::x86::avxneconvert | _mm256_bcstnesh_ps | function | ||
| 3955 | core::core_arch::x86::avxneconvert | _mm256_cvtneebf16_ps | function | ||
| 3956 | core::core_arch::x86::avxneconvert | _mm256_cvtneeph_ps | function | ||
| 3957 | core::core_arch::x86::avxneconvert | _mm256_cvtneobf16_ps | function | ||
| 3958 | core::core_arch::x86::avxneconvert | _mm256_cvtneoph_ps | function | ||
| 3959 | core::core_arch::x86::avxneconvert | _mm_bcstnebf16_ps | function | ||
| 3960 | core::core_arch::x86::avxneconvert | _mm_bcstnesh_ps | function | ||
| 3961 | core::core_arch::x86::avxneconvert | _mm_cvtneebf16_ps | function | ||
| 3962 | core::core_arch::x86::avxneconvert | _mm_cvtneeph_ps | function | ||
| 3963 | core::core_arch::x86::avxneconvert | _mm_cvtneobf16_ps | function | ||
| 3964 | core::core_arch::x86::avxneconvert | _mm_cvtneoph_ps | function | ||
| 3965 | core::core_arch::x86::bt | _bittest | function | ||
| 3966 | core::core_arch::x86::bt | _bittestandcomplement | function | ||
| 3967 | core::core_arch::x86::bt | _bittestandreset | function | ||
| 3968 | core::core_arch::x86::bt | _bittestandset | function | ||
| 3969 | core::core_arch::x86::fxsr | _fxrstor | function | ||
| 3970 | core::core_arch::x86::fxsr | _fxsave | function | ||
| 3971 | core::core_arch::x86::kl | _mm_aesdec128kl_u8 | function | ||
| 3972 | core::core_arch::x86::kl | _mm_aesdec256kl_u8 | function | ||
| 3973 | core::core_arch::x86::kl | _mm_aesdecwide128kl_u8 | function | ||
| 3974 | core::core_arch::x86::kl | _mm_aesdecwide256kl_u8 | function | ||
| 3975 | core::core_arch::x86::kl | _mm_aesenc128kl_u8 | function | ||
| 3976 | core::core_arch::x86::kl | _mm_aesenc256kl_u8 | function | ||
| 3977 | core::core_arch::x86::kl | _mm_aesencwide128kl_u8 | function | ||
| 3978 | core::core_arch::x86::kl | _mm_aesencwide256kl_u8 | function | ||
| 3979 | core::core_arch::x86::kl | _mm_encodekey128_u32 | function | ||
| 3980 | core::core_arch::x86::kl | _mm_encodekey256_u32 | function | ||
| 3981 | core::core_arch::x86::kl | _mm_loadiwkey | function | ||
| 3982 | core::core_arch::x86::rdtsc | __rdtscp | function | ||
| 3983 | core::core_arch::x86::rdtsc | _rdtsc | function | ||
| 3984 | core::core_arch::x86::rtm | _xabort | function | ||
| 3985 | core::core_arch::x86::rtm | _xbegin | function | ||
| 3986 | core::core_arch::x86::rtm | _xend | function | ||
| 3987 | core::core_arch::x86::rtm | _xtest | function | ||
| 3988 | core::core_arch::x86::sse | _MM_GET_EXCEPTION_MASK | function | ||
| 3989 | core::core_arch::x86::sse | _MM_GET_EXCEPTION_STATE | function | ||
| 3990 | core::core_arch::x86::sse | _MM_GET_FLUSH_ZERO_MODE | function | ||
| 3991 | core::core_arch::x86::sse | _MM_GET_ROUNDING_MODE | function | ||
| 3992 | core::core_arch::x86::sse | _MM_SET_EXCEPTION_MASK | function | ||
| 3993 | core::core_arch::x86::sse | _MM_SET_EXCEPTION_STATE | function | ||
| 3994 | core::core_arch::x86::sse | _MM_SET_FLUSH_ZERO_MODE | function | ||
| 3995 | core::core_arch::x86::sse | _MM_SET_ROUNDING_MODE | function | ||
| 3996 | core::core_arch::x86::sse | _mm_getcsr | function | ||
| 3997 | core::core_arch::x86::sse | _mm_load1_ps | function | ||
| 3998 | core::core_arch::x86::sse | _mm_load_ps | function | ||
| 3999 | core::core_arch::x86::sse | _mm_load_ps1 | function | ||
| 4000 | core::core_arch::x86::sse | _mm_load_ss | function | ||
| 4001 | core::core_arch::x86::sse | _mm_loadr_ps | function | ||
| 4002 | core::core_arch::x86::sse | _mm_loadu_ps | function | ||
| 4003 | core::core_arch::x86::sse | _mm_setcsr | function | ||
| 4004 | core::core_arch::x86::sse | _mm_store1_ps | function | ||
| 4005 | core::core_arch::x86::sse | _mm_store_ps | function | ||
| 4006 | core::core_arch::x86::sse | _mm_store_ps1 | function | ||
| 4007 | core::core_arch::x86::sse | _mm_store_ss | function | ||
| 4008 | core::core_arch::x86::sse | _mm_storer_ps | function | ||
| 4009 | core::core_arch::x86::sse | _mm_storeu_ps | function | ||
| 4010 | core::core_arch::x86::sse | _mm_stream_ps | function | 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. See [`_mm_sfence`] for details. | |
| 4011 | core::core_arch::x86::sse2 | _mm_clflush | function | ||
| 4012 | core::core_arch::x86::sse2 | _mm_load1_pd | function | ||
| 4013 | core::core_arch::x86::sse2 | _mm_load_pd | function | ||
| 4014 | core::core_arch::x86::sse2 | _mm_load_pd1 | function | ||
| 4015 | core::core_arch::x86::sse2 | _mm_load_sd | function | ||
| 4016 | core::core_arch::x86::sse2 | _mm_load_si128 | function | ||
| 4017 | core::core_arch::x86::sse2 | _mm_loadh_pd | function | ||
| 4018 | core::core_arch::x86::sse2 | _mm_loadl_epi64 | function | ||
| 4019 | core::core_arch::x86::sse2 | _mm_loadl_pd | function | ||
| 4020 | core::core_arch::x86::sse2 | _mm_loadr_pd | function | ||
| 4021 | core::core_arch::x86::sse2 | _mm_loadu_pd | function | ||
| 4022 | core::core_arch::x86::sse2 | _mm_loadu_si128 | function | ||
| 4023 | core::core_arch::x86::sse2 | _mm_loadu_si16 | function | ||
| 4024 | core::core_arch::x86::sse2 | _mm_loadu_si32 | function | ||
| 4025 | core::core_arch::x86::sse2 | _mm_loadu_si64 | function | ||
| 4026 | core::core_arch::x86::sse2 | _mm_maskmoveu_si128 | function | 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. See [`_mm_sfence`] for details. | |
| 4027 | core::core_arch::x86::sse2 | _mm_store1_pd | function | ||
| 4028 | core::core_arch::x86::sse2 | _mm_store_pd | function | ||
| 4029 | core::core_arch::x86::sse2 | _mm_store_pd1 | function | ||
| 4030 | core::core_arch::x86::sse2 | _mm_store_sd | function | ||
| 4031 | core::core_arch::x86::sse2 | _mm_store_si128 | function | ||
| 4032 | core::core_arch::x86::sse2 | _mm_storeh_pd | function | ||
| 4033 | core::core_arch::x86::sse2 | _mm_storel_epi64 | function | ||
| 4034 | core::core_arch::x86::sse2 | _mm_storel_pd | function | ||
| 4035 | core::core_arch::x86::sse2 | _mm_storer_pd | function | ||
| 4036 | core::core_arch::x86::sse2 | _mm_storeu_pd | function | ||
| 4037 | core::core_arch::x86::sse2 | _mm_storeu_si128 | function | ||
| 4038 | core::core_arch::x86::sse2 | _mm_storeu_si16 | function | ||
| 4039 | core::core_arch::x86::sse2 | _mm_storeu_si32 | function | ||
| 4040 | core::core_arch::x86::sse2 | _mm_storeu_si64 | function | ||
| 4041 | core::core_arch::x86::sse2 | _mm_stream_pd | function | 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. See [`_mm_sfence`] for details. | |
| 4042 | core::core_arch::x86::sse2 | _mm_stream_si128 | function | 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. See [`_mm_sfence`] for details. | |
| 4043 | core::core_arch::x86::sse2 | _mm_stream_si32 | function | 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. See [`_mm_sfence`] for details. | |
| 4044 | core::core_arch::x86::sse3 | _mm_lddqu_si128 | function | ||
| 4045 | core::core_arch::x86::sse3 | _mm_loaddup_pd | function | ||
| 4046 | core::core_arch::x86::sse41 | _mm_stream_load_si128 | function | ||
| 4047 | core::core_arch::x86::sse4a | _mm_stream_sd | function | 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. See [`_mm_sfence`] for details. | |
| 4048 | core::core_arch::x86::sse4a | _mm_stream_ss | function | 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. See [`_mm_sfence`] for details. | |
| 4049 | core::core_arch::x86::xsave | _xgetbv | function | ||
| 4050 | core::core_arch::x86::xsave | _xrstor | function | ||
| 4051 | core::core_arch::x86::xsave | _xrstors | function | ||
| 4052 | core::core_arch::x86::xsave | _xsave | function | ||
| 4053 | core::core_arch::x86::xsave | _xsavec | function | ||
| 4054 | core::core_arch::x86::xsave | _xsaveopt | function | ||
| 4055 | core::core_arch::x86::xsave | _xsaves | function | ||
| 4056 | core::core_arch::x86::xsave | _xsetbv | function | ||
| 4057 | core::core_arch::x86_64::amx | _tile_cmmimfp16ps | function | ||
| 4058 | core::core_arch::x86_64::amx | _tile_cmmrlfp16ps | function | ||
| 4059 | core::core_arch::x86_64::amx | _tile_cvtrowd2ps | function | ||
| 4060 | core::core_arch::x86_64::amx | _tile_cvtrowd2psi | function | ||
| 4061 | core::core_arch::x86_64::amx | _tile_cvtrowps2phh | function | ||
| 4062 | core::core_arch::x86_64::amx | _tile_cvtrowps2phhi | function | ||
| 4063 | core::core_arch::x86_64::amx | _tile_cvtrowps2phl | function | ||
| 4064 | core::core_arch::x86_64::amx | _tile_cvtrowps2phli | function | ||
| 4065 | core::core_arch::x86_64::amx | _tile_dpbf16ps | function | ||
| 4066 | core::core_arch::x86_64::amx | _tile_dpbf8ps | function | ||
| 4067 | core::core_arch::x86_64::amx | _tile_dpbhf8ps | function | ||
| 4068 | core::core_arch::x86_64::amx | _tile_dpbssd | function | ||
| 4069 | core::core_arch::x86_64::amx | _tile_dpbsud | function | ||
| 4070 | core::core_arch::x86_64::amx | _tile_dpbusd | function | ||
| 4071 | core::core_arch::x86_64::amx | _tile_dpbuud | function | ||
| 4072 | core::core_arch::x86_64::amx | _tile_dpfp16ps | function | ||
| 4073 | core::core_arch::x86_64::amx | _tile_dphbf8ps | function | ||
| 4074 | core::core_arch::x86_64::amx | _tile_dphf8ps | function | ||
| 4075 | core::core_arch::x86_64::amx | _tile_loadconfig | function | ||
| 4076 | core::core_arch::x86_64::amx | _tile_loadd | function | ||
| 4077 | core::core_arch::x86_64::amx | _tile_loaddrs | function | ||
| 4078 | core::core_arch::x86_64::amx | _tile_mmultf32ps | function | ||
| 4079 | core::core_arch::x86_64::amx | _tile_movrow | function | ||
| 4080 | core::core_arch::x86_64::amx | _tile_movrowi | function | ||
| 4081 | core::core_arch::x86_64::amx | _tile_release | function | ||
| 4082 | core::core_arch::x86_64::amx | _tile_storeconfig | function | ||
| 4083 | core::core_arch::x86_64::amx | _tile_stored | function | ||
| 4084 | core::core_arch::x86_64::amx | _tile_stream_loadd | function | ||
| 4085 | core::core_arch::x86_64::amx | _tile_stream_loaddrs | function | ||
| 4086 | core::core_arch::x86_64::amx | _tile_zero | function | ||
| 4087 | core::core_arch::x86_64::bt | _bittest64 | function | ||
| 4088 | core::core_arch::x86_64::bt | _bittestandcomplement64 | function | ||
| 4089 | core::core_arch::x86_64::bt | _bittestandreset64 | function | ||
| 4090 | core::core_arch::x86_64::bt | _bittestandset64 | function | ||
| 4091 | core::core_arch::x86_64::cmpxchg16b | cmpxchg16b | function | ||
| 4092 | core::core_arch::x86_64::fxsr | _fxrstor64 | function | ||
| 4093 | core::core_arch::x86_64::fxsr | _fxsave64 | function | ||
| 4094 | core::core_arch::x86_64::movrs | _movrs_i16 | function | ||
| 4095 | core::core_arch::x86_64::movrs | _movrs_i32 | function | ||
| 4096 | core::core_arch::x86_64::movrs | _movrs_i64 | function | ||
| 4097 | core::core_arch::x86_64::movrs | _movrs_i8 | function | ||
| 4098 | core::core_arch::x86_64::sse2 | _mm_stream_si64 | function | 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. See [`_mm_sfence`] for details. | |
| 4099 | core::core_arch::x86_64::xsave | _xrstor64 | function | ||
| 4100 | core::core_arch::x86_64::xsave | _xrstors64 | function | ||
| 4101 | core::core_arch::x86_64::xsave | _xsave64 | function | ||
| 4102 | core::core_arch::x86_64::xsave | _xsavec64 | function | ||
| 4103 | core::core_arch::x86_64::xsave | _xsaveopt64 | function | ||
| 4104 | core::core_arch::x86_64::xsave | _xsaves64 | function | ||
| 4105 | core::core_simd::cast::sealed | Sealed | trait | Implementing this trait asserts that the type is a valid vector element for the `simd_cast` or `simd_as` intrinsics. | |
| 4106 | core::core_simd::masks | MaskElement | trait | Type must be a signed integer. | |
| 4107 | core::core_simd::masks::Mask | from_simd_unchecked | function | All elements must be either 0 or -1. | |
| 4108 | core::core_simd::masks::Mask | set_unchecked | function | `index` must be less than `self.len()`. | |
| 4109 | core::core_simd::masks::Mask | test_unchecked | function | `index` must be less than `self.len()`. | |
| 4110 | core::core_simd::vector | SimdElement | trait | 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. | |
| 4111 | core::core_simd::vector::Simd | gather_ptr | function | Each read must satisfy the same conditions as [`core::ptr::read`]. | |
| 4112 | core::core_simd::vector::Simd | gather_select_ptr | function | Enabled elements must satisfy the same conditions as [`core::ptr::read`]. | |
| 4113 | core::core_simd::vector::Simd | gather_select_unchecked | function | Calling this function with an `enable`d out-of-bounds index is *[undefined behavior]* even if the resulting value is not used. | |
| 4114 | core::core_simd::vector::Simd | load_select_ptr | function | Enabled `ptr` elements must be safe to read as if by `core::ptr::read`. | |
| 4115 | core::core_simd::vector::Simd | load_select_unchecked | function | Enabled loads must not exceed the length of `slice`. | |
| 4116 | core::core_simd::vector::Simd | scatter_ptr | function | Each write must satisfy the same conditions as [`core::ptr::write`]. | |
| 4117 | core::core_simd::vector::Simd | scatter_select_ptr | function | Enabled pointers must satisfy the same conditions as [`core::ptr::write`]. | |
| 4118 | core::core_simd::vector::Simd | scatter_select_unchecked | function | Calling this function with an enabled out-of-bounds index is *[undefined behavior]*, and may lead to memory corruption. | |
| 4119 | core::core_simd::vector::Simd | store_select_ptr | function | Memory addresses for element are calculated [`pointer::wrapping_offset`] and each enabled element must satisfy the same conditions as [`core::ptr::write`]. | |
| 4120 | core::core_simd::vector::Simd | store_select_unchecked | function | Every enabled element must be in bounds for the `slice`. | |
| 4121 | core::f128 | to_int_unchecked | function | The value must: * Not be `NaN` * Not be infinite * Be representable in the return type `Int`, after truncating off its fractional part | |
| 4122 | core::f16 | to_int_unchecked | function | The value must: * Not be `NaN` * Not be infinite * Be representable in the return type `Int`, after truncating off its fractional part | |
| 4123 | core::f32 | to_int_unchecked | function | The value must: * Not be `NaN` * Not be infinite * Be representable in the return type `Int`, after truncating off its fractional part | |
| 4124 | core::f64 | to_int_unchecked | function | The value must: * Not be `NaN` * Not be infinite * Be representable in the return type `Int`, after truncating off its fractional part | |
| 4125 | core::ffi | VaArgSafe | trait | The standard library implements this trait for primitive types that are expected to have a variable argument application-binary interface (ABI) on all platforms. When C passes variable arguments, integers smaller than [`c_int`] and floats smaller than [`c_double`] are implicitly promoted to [`c_int`] and [`c_double`] respectively. Implementing this trait for types that are subject to this promotion rule is invalid. [`c_int`]: core::ffi::c_int [`c_double`]: core::ffi::c_double | |
| 4126 | core::ffi::c_str::CStr | from_bytes_with_nul_unchecked | function | The provided slice **must** be nul-terminated and not contain any interior nul bytes. | |
| 4127 | core::ffi::c_str::CStr | from_ptr | function | * 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. | |
| 4128 | core::ffi::va_list::VaList | arg | function | This function is only sound to call when there is another argument to read, and that argument is a properly initialized value of the type `T`. Calling this function with an incompatible type, an invalid value, or when there are no more variable arguments, is unsound. | |
| 4129 | core::field | Field | trait | Given a valid value of type `Self::Base`, there exists a valid value of type `Self::Type` at byte offset `OFFSET` | |
| 4130 | core::future | async_drop_in_place | function | 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. [ptr::drop_in_place]: crate::ptr::drop_in_place() | |
| 4131 | core::hint | assert_unchecked | function | `cond` must be `true`. It is immediate UB to call this with `false`. | |
| 4132 | core::hint | unreachable_unchecked | function | Reaching this function is *Undefined Behavior*. 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. | |
| 4133 | core::i128 | unchecked_add | function | This results in undefined behavior when `self + rhs > i128::MAX` or `self + rhs < i128::MIN`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: i128::checked_add [`wrapping_add`]: i128::wrapping_add | |
| 4134 | core::i128 | unchecked_div_exact | function | 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`. | |
| 4135 | core::i128 | unchecked_mul | function | This results in undefined behavior when `self * rhs > i128::MAX` or `self * rhs < i128::MIN`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: i128::checked_mul [`wrapping_mul`]: i128::wrapping_mul | |
| 4136 | core::i128 | unchecked_neg | function | This results in undefined behavior when `self == i128::MIN`, i.e. when [`checked_neg`] would return `None`. [`checked_neg`]: i128::checked_neg | |
| 4137 | core::i128 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: i128::checked_shl | |
| 4138 | core::i128 | unchecked_shl_exact | function | This results in undefined behavior when `rhs >= self.leading_zeros() && rhs >= self.leading_ones()` i.e. when [`i128::shl_exact`] would return `None`. | |
| 4139 | core::i128 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: i128::checked_shr | |
| 4140 | core::i128 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= i128::BITS` i.e. when [`i128::shr_exact`] would return `None`. | |
| 4141 | core::i128 | unchecked_sub | function | This results in undefined behavior when `self - rhs > i128::MAX` or `self - rhs < i128::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: i128::checked_sub [`wrapping_sub`]: i128::wrapping_sub | |
| 4142 | core::i16 | unchecked_add | function | This results in undefined behavior when `self + rhs > i16::MAX` or `self + rhs < i16::MIN`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: i16::checked_add [`wrapping_add`]: i16::wrapping_add | |
| 4143 | core::i16 | unchecked_div_exact | function | 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`. | |
| 4144 | core::i16 | unchecked_mul | function | This results in undefined behavior when `self * rhs > i16::MAX` or `self * rhs < i16::MIN`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: i16::checked_mul [`wrapping_mul`]: i16::wrapping_mul | |
| 4145 | core::i16 | unchecked_neg | function | This results in undefined behavior when `self == i16::MIN`, i.e. when [`checked_neg`] would return `None`. [`checked_neg`]: i16::checked_neg | |
| 4146 | core::i16 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: i16::checked_shl | |
| 4147 | core::i16 | unchecked_shl_exact | function | This results in undefined behavior when `rhs >= self.leading_zeros() && rhs >= self.leading_ones()` i.e. when [`i16::shl_exact`] would return `None`. | |
| 4148 | core::i16 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: i16::checked_shr | |
| 4149 | core::i16 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= i16::BITS` i.e. when [`i16::shr_exact`] would return `None`. | |
| 4150 | core::i16 | unchecked_sub | function | This results in undefined behavior when `self - rhs > i16::MAX` or `self - rhs < i16::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: i16::checked_sub [`wrapping_sub`]: i16::wrapping_sub | |
| 4151 | core::i32 | unchecked_add | function | This results in undefined behavior when `self + rhs > i32::MAX` or `self + rhs < i32::MIN`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: i32::checked_add [`wrapping_add`]: i32::wrapping_add | |
| 4152 | core::i32 | unchecked_div_exact | function | 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`. | |
| 4153 | core::i32 | unchecked_mul | function | This results in undefined behavior when `self * rhs > i32::MAX` or `self * rhs < i32::MIN`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: i32::checked_mul [`wrapping_mul`]: i32::wrapping_mul | |
| 4154 | core::i32 | unchecked_neg | function | This results in undefined behavior when `self == i32::MIN`, i.e. when [`checked_neg`] would return `None`. [`checked_neg`]: i32::checked_neg | |
| 4155 | core::i32 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: i32::checked_shl | |
| 4156 | core::i32 | unchecked_shl_exact | function | This results in undefined behavior when `rhs >= self.leading_zeros() && rhs >= self.leading_ones()` i.e. when [`i32::shl_exact`] would return `None`. | |
| 4157 | core::i32 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: i32::checked_shr | |
| 4158 | core::i32 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= i32::BITS` i.e. when [`i32::shr_exact`] would return `None`. | |
| 4159 | core::i32 | unchecked_sub | function | This results in undefined behavior when `self - rhs > i32::MAX` or `self - rhs < i32::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: i32::checked_sub [`wrapping_sub`]: i32::wrapping_sub | |
| 4160 | core::i64 | unchecked_add | function | This results in undefined behavior when `self + rhs > i64::MAX` or `self + rhs < i64::MIN`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: i64::checked_add [`wrapping_add`]: i64::wrapping_add | |
| 4161 | core::i64 | unchecked_div_exact | function | 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`. | |
| 4162 | core::i64 | unchecked_mul | function | This results in undefined behavior when `self * rhs > i64::MAX` or `self * rhs < i64::MIN`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: i64::checked_mul [`wrapping_mul`]: i64::wrapping_mul | |
| 4163 | core::i64 | unchecked_neg | function | This results in undefined behavior when `self == i64::MIN`, i.e. when [`checked_neg`] would return `None`. [`checked_neg`]: i64::checked_neg | |
| 4164 | core::i64 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: i64::checked_shl | |
| 4165 | core::i64 | unchecked_shl_exact | function | This results in undefined behavior when `rhs >= self.leading_zeros() && rhs >= self.leading_ones()` i.e. when [`i64::shl_exact`] would return `None`. | |
| 4166 | core::i64 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: i64::checked_shr | |
| 4167 | core::i64 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= i64::BITS` i.e. when [`i64::shr_exact`] would return `None`. | |
| 4168 | core::i64 | unchecked_sub | function | This results in undefined behavior when `self - rhs > i64::MAX` or `self - rhs < i64::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: i64::checked_sub [`wrapping_sub`]: i64::wrapping_sub | |
| 4169 | core::i8 | unchecked_add | function | This results in undefined behavior when `self + rhs > i8::MAX` or `self + rhs < i8::MIN`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: i8::checked_add [`wrapping_add`]: i8::wrapping_add | |
| 4170 | core::i8 | unchecked_div_exact | function | 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`. | |
| 4171 | core::i8 | unchecked_mul | function | This results in undefined behavior when `self * rhs > i8::MAX` or `self * rhs < i8::MIN`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: i8::checked_mul [`wrapping_mul`]: i8::wrapping_mul | |
| 4172 | core::i8 | unchecked_neg | function | This results in undefined behavior when `self == i8::MIN`, i.e. when [`checked_neg`] would return `None`. [`checked_neg`]: i8::checked_neg | |
| 4173 | core::i8 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: i8::checked_shl | |
| 4174 | core::i8 | unchecked_shl_exact | function | This results in undefined behavior when `rhs >= self.leading_zeros() && rhs >= self.leading_ones()` i.e. when [`i8::shl_exact`] would return `None`. | |
| 4175 | core::i8 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: i8::checked_shr | |
| 4176 | core::i8 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= i8::BITS` i.e. when [`i8::shr_exact`] would return `None`. | |
| 4177 | core::i8 | unchecked_sub | function | This results in undefined behavior when `self - rhs > i8::MAX` or `self - rhs < i8::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: i8::checked_sub [`wrapping_sub`]: i8::wrapping_sub | |
| 4178 | core::intrinsics | align_of_val | function | See [`crate::mem::align_of_val_raw`] for safety conditions. | |
| 4179 | core::intrinsics | arith_offset | function | 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`]. | |
| 4180 | core::intrinsics | assume | function | ||
| 4181 | core::intrinsics | atomic_and | function | ||
| 4182 | core::intrinsics | atomic_cxchg | function | ||
| 4183 | core::intrinsics | atomic_cxchgweak | function | ||
| 4184 | core::intrinsics | atomic_fence | function | ||
| 4185 | core::intrinsics | atomic_load | function | ||
| 4186 | core::intrinsics | atomic_max | function | ||
| 4187 | core::intrinsics | atomic_min | function | ||
| 4188 | core::intrinsics | atomic_nand | function | ||
| 4189 | core::intrinsics | atomic_or | function | ||
| 4190 | core::intrinsics | atomic_singlethreadfence | function | ||
| 4191 | core::intrinsics | atomic_store | function | ||
| 4192 | core::intrinsics | atomic_umax | function | ||
| 4193 | core::intrinsics | atomic_umin | function | ||
| 4194 | core::intrinsics | atomic_xadd | function | ||
| 4195 | core::intrinsics | atomic_xchg | function | ||
| 4196 | core::intrinsics | atomic_xor | function | ||
| 4197 | core::intrinsics | atomic_xsub | function | ||
| 4198 | core::intrinsics | catch_unwind | function | ||
| 4199 | core::intrinsics | compare_bytes | function | `left` and `right` must each be [valid] for reads of `bytes` bytes. Note that this applies to the whole range, not just until the first byte that differs. That allows optimizations that can read in large chunks. [valid]: crate::ptr#safety | |
| 4200 | core::intrinsics | const_allocate | function | - The `align` argument must be a power of two. - At compile time, a compile error occurs if this constraint is violated. - At runtime, it is not checked. | |
| 4201 | core::intrinsics | const_deallocate | function | - The `align` argument must be a power of two. - At compile time, a compile error occurs if this constraint is violated. - At runtime, it is not checked. - If the `ptr` is created in an another const, this intrinsic doesn't deallocate it. - If the `ptr` is pointing to a local variable, this intrinsic doesn't deallocate it. | |
| 4202 | core::intrinsics | const_make_global | function | ||
| 4203 | core::intrinsics | copy | function | ||
| 4204 | core::intrinsics | copy_nonoverlapping | function | ||
| 4205 | core::intrinsics | ctlz_nonzero | function | ||
| 4206 | core::intrinsics | cttz_nonzero | function | ||
| 4207 | core::intrinsics | disjoint_bitor | function | Requires that `(a & b) == 0`, or equivalently that `(a | b) == (a + b)`. Otherwise it's immediate UB. | |
| 4208 | core::intrinsics | exact_div | function | ||
| 4209 | core::intrinsics | fadd_fast | function | ||
| 4210 | core::intrinsics | fdiv_fast | function | ||
| 4211 | core::intrinsics | float_to_int_unchecked | function | ||
| 4212 | core::intrinsics | fmul_fast | function | ||
| 4213 | core::intrinsics | frem_fast | function | ||
| 4214 | core::intrinsics | fsub_fast | function | ||
| 4215 | core::intrinsics | nontemporal_store | function | ||
| 4216 | core::intrinsics | offset | function | 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`]. | |
| 4217 | core::intrinsics | ptr_offset_from | function | ||
| 4218 | core::intrinsics | ptr_offset_from_unsigned | function | ||
| 4219 | core::intrinsics | raw_eq | function | 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`.) | |
| 4220 | core::intrinsics | read_via_copy | function | ||
| 4221 | core::intrinsics | size_of_val | function | See [`crate::mem::size_of_val_raw`] for safety conditions. | |
| 4222 | core::intrinsics | slice_get_unchecked | function | - `index < PtrMetadata(slice_ptr)`, so the indexing is in-bounds for the slice - the resulting offsetting is in-bounds of the allocation, which is always the case for references, but needs to be upheld manually for pointers | |
| 4223 | core::intrinsics | transmute_unchecked | function | ||
| 4224 | core::intrinsics | typed_swap_nonoverlapping | function | Behavior is undefined if any of the following conditions are violated: * Both `x` and `y` must be [valid] for both reads and writes. * Both `x` and `y` must be properly aligned. * The region of memory beginning at `x` must *not* overlap with the region of memory beginning at `y`. * The memory pointed by `x` and `y` must both contain values of type `T`. [valid]: crate::ptr#safety | |
| 4225 | core::intrinsics | unaligned_volatile_load | function | ||
| 4226 | core::intrinsics | unaligned_volatile_store | function | ||
| 4227 | core::intrinsics | unchecked_add | function | ||
| 4228 | core::intrinsics | unchecked_div | function | ||
| 4229 | core::intrinsics | unchecked_funnel_shl | function | ||
| 4230 | core::intrinsics | unchecked_funnel_shr | function | ||
| 4231 | core::intrinsics | unchecked_mul | function | ||
| 4232 | core::intrinsics | unchecked_rem | function | ||
| 4233 | core::intrinsics | unchecked_shl | function | ||
| 4234 | core::intrinsics | unchecked_shr | function | ||
| 4235 | core::intrinsics | unchecked_sub | function | ||
| 4236 | core::intrinsics | unreachable | function | ||
| 4237 | core::intrinsics | va_arg | function | This function is only sound to call when: - there is a next variable argument available. - the next argument's type must be ABI-compatible with the type `T`. - the next argument must have a properly initialized value of type `T`. Calling this function with an incompatible type, an invalid value, or when there are no more variable arguments, is unsound. | |
| 4238 | core::intrinsics | va_end | function | `ap` must not be used to access variable arguments after this call. | |
| 4239 | core::intrinsics | volatile_copy_memory | function | ||
| 4240 | core::intrinsics | volatile_copy_nonoverlapping_memory | function | 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. [`copy_nonoverlapping`]: ptr::copy_nonoverlapping | |
| 4241 | core::intrinsics | volatile_load | function | ||
| 4242 | core::intrinsics | volatile_set_memory | function | 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. [`write_bytes`]: ptr::write_bytes | |
| 4243 | core::intrinsics | volatile_store | function | ||
| 4244 | core::intrinsics | vtable_align | function | `ptr` must point to a vtable. | |
| 4245 | core::intrinsics | vtable_size | function | `ptr` must point to a vtable. | |
| 4246 | core::intrinsics | write_bytes | function | ||
| 4247 | core::intrinsics | write_via_move | function | ||
| 4248 | core::intrinsics::bounds | BuiltinDeref | trait | Must actually *be* such a type. | |
| 4249 | core::intrinsics::bounds | FloatPrimitive | trait | Must actually *be* such a type. | |
| 4250 | core::intrinsics::simd | simd_add | function | ||
| 4251 | core::intrinsics::simd | simd_and | function | ||
| 4252 | core::intrinsics::simd | simd_arith_offset | function | ||
| 4253 | core::intrinsics::simd | simd_as | function | ||
| 4254 | core::intrinsics::simd | simd_bitmask | function | `x` must contain only `0` and `!0`. | |
| 4255 | core::intrinsics::simd | simd_bitreverse | function | ||
| 4256 | core::intrinsics::simd | simd_bswap | function | ||
| 4257 | core::intrinsics::simd | simd_carryless_mul | function | ||
| 4258 | core::intrinsics::simd | simd_cast | function | 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 | |
| 4259 | core::intrinsics::simd | simd_cast_ptr | function | ||
| 4260 | core::intrinsics::simd | simd_ceil | function | ||
| 4261 | core::intrinsics::simd | simd_ctlz | function | ||
| 4262 | core::intrinsics::simd | simd_ctpop | function | ||
| 4263 | core::intrinsics::simd | simd_cttz | function | ||
| 4264 | core::intrinsics::simd | simd_div | function | For integers, `rhs` must not contain any zero elements. Additionally for signed integers, `<int>::MIN / -1` is undefined behavior. | |
| 4265 | core::intrinsics::simd | simd_eq | function | ||
| 4266 | core::intrinsics::simd | simd_expose_provenance | function | ||
| 4267 | core::intrinsics::simd | simd_extract | function | `idx` must be const and in-bounds of the vector. | |
| 4268 | core::intrinsics::simd | simd_extract_dyn | function | `idx` must be in-bounds of the vector. | |
| 4269 | core::intrinsics::simd | simd_fabs | function | ||
| 4270 | core::intrinsics::simd | simd_fcos | function | ||
| 4271 | core::intrinsics::simd | simd_fexp | function | ||
| 4272 | core::intrinsics::simd | simd_fexp2 | function | ||
| 4273 | core::intrinsics::simd | simd_flog | function | ||
| 4274 | core::intrinsics::simd | simd_flog10 | function | ||
| 4275 | core::intrinsics::simd | simd_flog2 | function | ||
| 4276 | core::intrinsics::simd | simd_floor | function | ||
| 4277 | core::intrinsics::simd | simd_fma | function | ||
| 4278 | core::intrinsics::simd | simd_fsin | function | ||
| 4279 | core::intrinsics::simd | simd_fsqrt | function | ||
| 4280 | core::intrinsics::simd | simd_funnel_shl | function | Each element of `shift` must be less than `<int>::BITS`. | |
| 4281 | core::intrinsics::simd | simd_funnel_shr | function | Each element of `shift` must be less than `<int>::BITS`. | |
| 4282 | core::intrinsics::simd | simd_gather | function | Unmasked values in `T` must be readable as if by `<ptr>::read` (e.g. aligned to the element type). `mask` must only contain `0` or `!0` values. | |
| 4283 | core::intrinsics::simd | simd_ge | function | ||
| 4284 | core::intrinsics::simd | simd_gt | function | ||
| 4285 | core::intrinsics::simd | simd_insert | function | `idx` must be in-bounds of the vector. | |
| 4286 | core::intrinsics::simd | simd_insert_dyn | function | `idx` must be in-bounds of the vector. | |
| 4287 | core::intrinsics::simd | simd_le | function | ||
| 4288 | core::intrinsics::simd | simd_lt | function | ||
| 4289 | core::intrinsics::simd | simd_masked_load | function | `ptr` must be aligned according to the `ALIGN` parameter, see [`SimdAlign`] for details. `mask` must only contain `0` or `!0` values. | |
| 4290 | core::intrinsics::simd | simd_masked_store | function | `ptr` must be aligned according to the `ALIGN` parameter, see [`SimdAlign`] for details. `mask` must only contain `0` or `!0` values. | |
| 4291 | core::intrinsics::simd | simd_maximum_number_nsz | function | ||
| 4292 | core::intrinsics::simd | simd_minimum_number_nsz | function | ||
| 4293 | core::intrinsics::simd | simd_mul | function | ||
| 4294 | core::intrinsics::simd | simd_ne | function | ||
| 4295 | core::intrinsics::simd | simd_neg | function | ||
| 4296 | core::intrinsics::simd | simd_or | function | ||
| 4297 | core::intrinsics::simd | simd_reduce_add_ordered | function | ||
| 4298 | core::intrinsics::simd | simd_reduce_add_unordered | function | ||
| 4299 | core::intrinsics::simd | simd_reduce_all | function | `x` must contain only `0` or `!0`. | |
| 4300 | core::intrinsics::simd | simd_reduce_and | function | ||
| 4301 | core::intrinsics::simd | simd_reduce_any | function | `x` must contain only `0` or `!0`. | |
| 4302 | core::intrinsics::simd | simd_reduce_max | function | ||
| 4303 | core::intrinsics::simd | simd_reduce_min | function | ||
| 4304 | core::intrinsics::simd | simd_reduce_mul_ordered | function | ||
| 4305 | core::intrinsics::simd | simd_reduce_mul_unordered | function | ||
| 4306 | core::intrinsics::simd | simd_reduce_or | function | ||
| 4307 | core::intrinsics::simd | simd_reduce_xor | function | ||
| 4308 | core::intrinsics::simd | simd_relaxed_fma | function | ||
| 4309 | core::intrinsics::simd | simd_rem | function | For integers, `rhs` must not contain any zero elements. Additionally for signed integers, `<int>::MIN / -1` is undefined behavior. | |
| 4310 | core::intrinsics::simd | simd_round | function | ||
| 4311 | core::intrinsics::simd | simd_round_ties_even | function | ||
| 4312 | core::intrinsics::simd | simd_saturating_add | function | ||
| 4313 | core::intrinsics::simd | simd_saturating_sub | function | ||
| 4314 | core::intrinsics::simd | simd_scatter | function | Unmasked values in `T` must be writeable as if by `<ptr>::write` (e.g. aligned to the element type). `mask` must only contain `0` or `!0` values. | |
| 4315 | core::intrinsics::simd | simd_select | function | `mask` must only contain `0` and `!0`. | |
| 4316 | core::intrinsics::simd | simd_select_bitmask | function | ||
| 4317 | core::intrinsics::simd | simd_shl | function | Each element of `rhs` must be less than `<int>::BITS`. | |
| 4318 | core::intrinsics::simd | simd_shr | function | Each element of `rhs` must be less than `<int>::BITS`. | |
| 4319 | core::intrinsics::simd | simd_shuffle | function | ||
| 4320 | core::intrinsics::simd | simd_splat | function | ||
| 4321 | core::intrinsics::simd | simd_sub | function | ||
| 4322 | core::intrinsics::simd | simd_trunc | function | ||
| 4323 | core::intrinsics::simd | simd_with_exposed_provenance | function | ||
| 4324 | core::intrinsics::simd | simd_xor | function | ||
| 4325 | core::intrinsics::simd::scalable | sve_tuple_create2 | function | ||
| 4326 | core::intrinsics::simd::scalable | sve_tuple_create3 | function | ||
| 4327 | core::intrinsics::simd::scalable | sve_tuple_create4 | function | ||
| 4328 | core::intrinsics::simd::scalable | sve_tuple_get | function | `IDX` must be in-bounds of the tuple. | |
| 4329 | core::intrinsics::simd::scalable | sve_tuple_set | function | `IDX` must be in-bounds of the tuple. | |
| 4330 | core::io::borrowed_buf::BorrowedBuf | set_init | function | All the bytes of the buffer must be initialized. | |
| 4331 | core::io::borrowed_buf::BorrowedCursor | advance | function | The caller must ensure that the first `n` bytes of the cursor have been properly initialised. | |
| 4332 | core::io::borrowed_buf::BorrowedCursor | as_mut | function | The caller must not uninitialize any bytes of the cursor if it is initialized. | |
| 4333 | core::io::borrowed_buf::BorrowedCursor | set_init | function | All the bytes of the cursor must be initialized. | |
| 4334 | core::isize | unchecked_add | function | This results in undefined behavior when `self + rhs > isize::MAX` or `self + rhs < isize::MIN`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: isize::checked_add [`wrapping_add`]: isize::wrapping_add | |
| 4335 | core::isize | unchecked_div_exact | function | 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`. | |
| 4336 | core::isize | unchecked_mul | function | This results in undefined behavior when `self * rhs > isize::MAX` or `self * rhs < isize::MIN`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: isize::checked_mul [`wrapping_mul`]: isize::wrapping_mul | |
| 4337 | core::isize | unchecked_neg | function | This results in undefined behavior when `self == isize::MIN`, i.e. when [`checked_neg`] would return `None`. [`checked_neg`]: isize::checked_neg | |
| 4338 | core::isize | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: isize::checked_shl | |
| 4339 | core::isize | unchecked_shl_exact | function | This results in undefined behavior when `rhs >= self.leading_zeros() && rhs >= self.leading_ones()` i.e. when [`isize::shl_exact`] would return `None`. | |
| 4340 | core::isize | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: isize::checked_shr | |
| 4341 | core::isize | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= isize::BITS` i.e. when [`isize::shr_exact`] would return `None`. | |
| 4342 | core::isize | unchecked_sub | function | This results in undefined behavior when `self - rhs > isize::MAX` or `self - rhs < isize::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: isize::checked_sub [`wrapping_sub`]: isize::wrapping_sub | |
| 4343 | core::iter | TrustedLen | trait | This trait must only be implemented when the contract is upheld. Consumers of this trait must inspect [`Iterator::size_hint()`]’s upper bound. | |
| 4344 | core::iter | TrustedStep | trait | 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. | |
| 4345 | core::marker | Freeze | trait | This trait is a core part of the language, it is just expressed as a trait in libcore for convenience. Do *not* implement it for other types. | |
| 4346 | core::marker | UnsafeUnpin | trait | ||
| 4347 | core::mem | TransmuteFrom | trait | 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: ```rust pub unsafe fn transmute_via_union<Src, Dst>(src: Src) -> Dst { use core::mem::ManuallyDrop; #[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.: ```rust #![feature(transmutability)] use core::mem::{Assume, TransmuteFrom}; let src = 42u8; // size = 1 #[repr(C, align(2))] struct Dst(u8); // size = 2 let _ = unsafe { <Dst as TransmuteFrom<u8, { Assume::SAFETY }>>::transmute(src) }; ``` | |
| 4348 | core::mem | align_of_val_raw | function | This function is only safe to call if the following conditions 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 [`align_of_val`] on a reference to a type with an extern type tail. - otherwise, it is conservatively not allowed to call this function. [trait object]: ../../book/ch17-02-trait-objects.html [extern type]: ../../unstable-book/language-features/extern-types.html | |
| 4349 | core::mem | conjure_zst | 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. | |
| 4350 | core::mem | size_of_val_raw | function | This function is only safe to call if the following conditions 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 [`size_of_val`] on a reference to a type with an extern type tail. - otherwise, it is conservatively not allowed to call this function. [`size_of::<T>()`]: size_of [trait object]: ../../book/ch17-02-trait-objects.html [extern type]: ../../unstable-book/language-features/extern-types.html | |
| 4351 | core::mem | transmute | function | ||
| 4352 | core::mem | transmute_copy | function | ||
| 4353 | core::mem | transmute_neo | function | ||
| 4354 | core::mem | transmute_prefix | function | 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. | |
| 4355 | core::mem | uninitialized | function | ||
| 4356 | core::mem | zeroed | function | ||
| 4357 | core::mem::alignment::Alignment | new_unchecked | function | `align` must be a power of two. Equivalently, it must be `1 << exp` for some `exp` in `0..usize::BITS`. It must *not* be zero. | |
| 4358 | core::mem::alignment::Alignment | of_val_raw | function | This function is only safe to call if the following conditions 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. [trait object]: ../../book/ch17-02-trait-objects.html [extern type]: ../../unstable-book/language-features/extern-types.html | |
| 4359 | core::mem::manually_drop::ManuallyDrop | drop | 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. [pinned]: crate::pin | |
| 4360 | core::mem::manually_drop::ManuallyDrop | take | function | 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. | |
| 4361 | core::mem::maybe_uninit::MaybeUninit | array_assume_init | function | It is up to the caller to guarantee that all elements of the array are in an initialized state. | |
| 4362 | core::mem::maybe_uninit::MaybeUninit | assume_init | function | 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]. [inv]: #initialization-invariant [validity]: ../../reference/behavior-considered-undefined.html#r-undefined.validity 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). [`Vec<T>`]: ../../std/vec/struct.Vec.html | |
| 4363 | core::mem::maybe_uninit::MaybeUninit | assume_init_drop | function | 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. [`assume_init`]: MaybeUninit::assume_init | |
| 4364 | core::mem::maybe_uninit::MaybeUninit | assume_init_mut | function | 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`. | |
| 4365 | core::mem::maybe_uninit::MaybeUninit | assume_init_read | function | 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. [inv]: #initialization-invariant [`assume_init`]: MaybeUninit::assume_init | |
| 4366 | core::mem::maybe_uninit::MaybeUninit | assume_init_ref | function | 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. | |
| 4367 | core::num | ZeroablePrimitive | trait | 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: - `Self::NonZeroInner` to `Option<Self::NonZeroInner>` - `Option<Self::NonZeroInner>` to `Self` (And, consequently, `Self::NonZeroInner` to `Self`.) | |
| 4368 | core::num::nonzero::NonZero | from_mut_unchecked | function | The referenced value must not be zero. | |
| 4369 | core::num::nonzero::NonZero | new_unchecked | function | The value must not be zero. | |
| 4370 | core::num::nonzero::NonZero | unchecked_add | function | This results in undefined behavior when `self + rhs > usize::MAX`. This results in undefined behavior when `self + rhs > u128::MAX`. This results in undefined behavior when `self + rhs > u64::MAX`. This results in undefined behavior when `self + rhs > u32::MAX`. This results in undefined behavior when `self + rhs > u16::MAX`. This results in undefined behavior when `self + rhs > u8::MAX`. | |
| 4371 | core::num::nonzero::NonZero | unchecked_mul | function | This results in undefined behavior when `self * rhs > i64::MAX`, or `self * rhs < i64::MIN`. This results in undefined behavior when `self * rhs > i8::MAX`, or `self * rhs < i8::MIN`. This results in undefined behavior when `self * rhs > isize::MAX`, or `self * rhs < isize::MIN`. This results in undefined behavior when `self * rhs > i32::MAX`, or `self * rhs < i32::MIN`. This results in undefined behavior when `self * rhs > usize::MAX`. This results in undefined behavior when `self * rhs > i128::MAX`, or `self * rhs < i128::MIN`. This results in undefined behavior when `self * rhs > u128::MAX`. This results in undefined behavior when `self * rhs > u64::MAX`. This results in undefined behavior when `self * rhs > u32::MAX`. This results in undefined behavior when `self * rhs > i16::MAX`, or `self * rhs < i16::MIN`. This results in undefined behavior when `self * rhs > u16::MAX`. This results in undefined behavior when `self * rhs > u8::MAX`. | |
| 4372 | core::ops | DerefPure | trait | ||
| 4373 | core::option::Option | unwrap_unchecked | function | Calling this method on [`None`] is *[undefined behavior]*. [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html | |
| 4374 | core::pin | PinCoerceUnsized | trait | 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. | |
| 4375 | core::pin::Pin | get_unchecked_mut | function | 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. | |
| 4376 | core::pin::Pin | into_inner_unchecked | function | 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. | |
| 4377 | core::pin::Pin | map_unchecked | 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. [`pin` module]: self#projections-and-structural-pinning | |
| 4378 | core::pin::Pin | map_unchecked_mut | 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. [`pin` module]: self#projections-and-structural-pinning | |
| 4379 | core::pin::Pin | new_unchecked | 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::deref` *on 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. } ``` | |
| 4380 | core::pointer | add | function | 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`. * 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 the result must be in bounds of that allocation. In particular, this range must not "wrap around" the edge of the address space. Allocations can never be larger than `isize::MAX` bytes, so if the computed offset stays in bounds of the allocation, it is guaranteed to satisfy the first requirement. This implies, for instance, that `vec.as_ptr().add(vec.len())` (for `vec: Vec<T>`) is always safe. Consider using [`wrapping_add`] instead if these constraints are difficult to satisfy. The only advantage of this method is that it enables more aggressive compiler optimizations. [`wrapping_add`]: #method.wrapping_add [allocation]: crate::ptr#allocation | |
| 4381 | core::pointer | as_mut | function | When calling this method, you have to ensure that *either* the pointer is null *or* the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion). | |
| 4382 | core::pointer | as_mut_unchecked | function | When calling this method, you have to ensure that the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion). | |
| 4383 | core::pointer | as_ref | function | When calling this method, you have to ensure that *either* the pointer is null *or* the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion). | |
| 4384 | core::pointer | as_ref_unchecked | function | When calling this method, you have to ensure that the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion). | |
| 4385 | core::pointer | as_uninit_mut | function | When calling this method, you have to ensure that *either* the pointer is null *or* the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion). | |
| 4386 | core::pointer | as_uninit_ref | function | When calling this method, you have to ensure that *either* the pointer is null *or* the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion). Note that because the created reference is to `MaybeUninit<T>`, the source pointer can point to uninitialized memory. | |
| 4387 | core::pointer | as_uninit_slice | function | 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 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! See also [`slice::from_raw_parts`][]. [valid]: crate::ptr#safety [allocation]: crate::ptr#allocation | |
| 4388 | core::pointer | as_uninit_slice_mut | function | 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! See also [`slice::from_raw_parts_mut`][]. [valid]: crate::ptr#safety [allocation]: crate::ptr#allocation | |
| 4389 | core::pointer | byte_add | function | ||
| 4390 | core::pointer | byte_offset | function | ||
| 4391 | core::pointer | byte_offset_from | function | ||
| 4392 | core::pointer | byte_offset_from_unsigned | function | ||
| 4393 | core::pointer | byte_sub | function | ||
| 4394 | core::pointer | copy_from | function | ||
| 4395 | core::pointer | copy_from_nonoverlapping | function | ||
| 4396 | core::pointer | copy_to | function | ||
| 4397 | core::pointer | copy_to_nonoverlapping | function | ||
| 4398 | core::pointer | drop_in_place | function | ||
| 4399 | core::pointer | get_unchecked | function | ||
| 4400 | core::pointer | get_unchecked_mut | function | ||
| 4401 | core::pointer | offset | function | 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`. * 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 the result must be in bounds of that allocation. In particular, this range must not "wrap around" the edge of the address space. Note that "range" here refers to a half-open range as usual in Rust, i.e., `self..result` for non-negative offsets and `result..self` for negative offsets. Allocations can never be larger than `isize::MAX` bytes, so if the computed offset stays in bounds of the allocation, it is guaranteed to satisfy the first requirement. This implies, for instance, that `vec.as_ptr().add(vec.len())` (for `vec: Vec<T>`) is always safe. Consider using [`wrapping_offset`] instead if these constraints are difficult to satisfy. The only advantage of this method is that it enables more aggressive compiler optimizations. [`wrapping_offset`]: #method.wrapping_offset [allocation]: crate::ptr#allocation | |
| 4402 | core::pointer | offset_from | function | 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 as isize - origin as isize) / size_of::<T>()`. [`add`]: #method.add [allocation]: crate::ptr#allocation | |
| 4403 | core::pointer | offset_from_unsigned | function | - 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::MAX` *bytes*. As such, the result of this method will always be less than or equal to `isize::MAX as usize`. | |
| 4404 | core::pointer | read | function | ||
| 4405 | core::pointer | read_unaligned | function | ||
| 4406 | core::pointer | read_volatile | function | ||
| 4407 | core::pointer | replace | function | ||
| 4408 | core::pointer | split_at_mut | function | `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. [`split_at_mut_unchecked`]: #method.split_at_mut_unchecked [in-bounds]: #method.add [allocation]: crate::ptr#allocation [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html | |
| 4409 | core::pointer | split_at_mut_unchecked | function | `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. [in-bounds]: #method.add [out-of-bounds index]: #method.add [allocation]: crate::ptr#allocation [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html | |
| 4410 | core::pointer | sub | function | 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`. * 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 the result must be in bounds of that allocation. In particular, this range must not "wrap around" the edge of the address space. Allocations can never be larger than `isize::MAX` bytes, so if the computed offset stays in bounds of the allocation, it is guaranteed to satisfy the first requirement. This implies, for instance, that `vec.as_ptr().add(vec.len())` (for `vec: Vec<T>`) is always safe. Consider using [`wrapping_sub`] instead if these constraints are difficult to satisfy. The only advantage of this method is that it enables more aggressive compiler optimizations. [`wrapping_sub`]: #method.wrapping_sub [allocation]: crate::ptr#allocation | |
| 4411 | core::pointer | swap | function | ||
| 4412 | core::pointer | write | function | ||
| 4413 | core::pointer | write_bytes | function | ||
| 4414 | core::pointer | write_unaligned | function | ||
| 4415 | core::pointer | write_volatile | function | ||
| 4416 | core::prelude::v1 | Send | trait | ||
| 4417 | core::prelude::v1 | Sync | trait | ||
| 4418 | core::ptr | copy | function | 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. [`read`]: crate::ptr::read [read-ownership]: crate::ptr::read#ownership-of-the-returned-value [valid]: crate::ptr#safety | |
| 4419 | core::ptr | copy_nonoverlapping | function | 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. [`read`]: crate::ptr::read [read-ownership]: crate::ptr::read#ownership-of-the-returned-value [valid]: crate::ptr#safety | |
| 4420 | core::ptr | drop_in_place | function | 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. [valid]: self#safety | |
| 4421 | core::ptr | read | function | Behavior is undefined if any of the following conditions are violated: * `src` must be [valid] for reads or `T` must be a ZST. * `src` must be properly aligned. Use [`read_unaligned`] if this is not the case. * `src` must point to a properly initialized value of type `T`. Note that even if `T` has size `0`, the pointer must be properly aligned. | |
| 4422 | core::ptr | read_unaligned | function | 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]. [read-ownership]: read#ownership-of-the-returned-value [valid]: self#safety | |
| 4423 | core::ptr | read_volatile | function | 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. [valid]: self#safety [read-ownership]: read#ownership-of-the-returned-value | |
| 4424 | core::ptr | replace | function | Behavior is undefined if any of the following conditions are violated: * `dst` must be [valid] for both reads and writes or `T` must be a ZST. * `dst` must be properly aligned. * `dst` must point to a properly initialized value of type `T`. Note that even if `T` has size `0`, the pointer must be properly aligned. [valid]: self#safety | |
| 4425 | core::ptr | swap | function | 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. [valid]: self#safety | |
| 4426 | core::ptr | swap_nonoverlapping | function | 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. [valid]: self#safety | |
| 4427 | core::ptr | write | function | Behavior is undefined if any of the following conditions are violated: * `dst` must be [valid] for writes or `T` must be a ZST. * `dst` must be properly aligned. Use [`write_unaligned`] if this is not the case. Note that even if `T` has size `0`, the pointer must be properly aligned. [valid]: self#safety | |
| 4428 | core::ptr | write_bytes | function | 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! ⚠️ } ``` [valid]: crate::ptr#safety | |
| 4429 | core::ptr | write_unaligned | function | Behavior is undefined if any of the following conditions are violated: * `dst` must be [valid] for writes. [valid]: self#safety | |
| 4430 | core::ptr | write_volatile | function | 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. [valid]: self#safety | |
| 4431 | core::ptr::non_null::NonNull | add | function | If any of the following conditions are violated, the result is Undefined Behavior: * The computed offset, `count * size_of::<T>()` bytes, must not overflow `isize`. * If the computed offset is non-zero, then `self` must be derived from a pointer to some [allocation], and the entire memory range between `self` and the result must be in bounds of that allocation. In particular, this range must not "wrap around" the edge of the address space. Allocations can never be larger than `isize::MAX` bytes, so if the computed offset stays in bounds of the allocation, it is guaranteed to satisfy the first requirement. This implies, for instance, that `vec.as_ptr().add(vec.len())` (for `vec: Vec<T>`) is always safe. [allocation]: crate::ptr#allocation | |
| 4432 | core::ptr::non_null::NonNull | as_mut | function | When calling this method, you have to ensure that the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion). | |
| 4433 | core::ptr::non_null::NonNull | as_ref | function | When calling this method, you have to ensure that the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion). | |
| 4434 | core::ptr::non_null::NonNull | as_uninit_mut | function | When calling this method, you have to ensure that the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion). Note that because the created reference is to `MaybeUninit<T>`, the source pointer can point to uninitialized memory. | |
| 4435 | core::ptr::non_null::NonNull | as_uninit_ref | function | When calling this method, you have to ensure that the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion). Note that because the created reference is to `MaybeUninit<T>`, the source pointer can point to uninitialized memory. | |
| 4436 | core::ptr::non_null::NonNull | as_uninit_slice | function | 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! See also [`slice::from_raw_parts`]. [valid]: crate::ptr#safety | |
| 4437 | core::ptr::non_null::NonNull | as_uninit_slice_mut | function | 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! See also [`slice::from_raw_parts_mut`]. [valid]: crate::ptr#safety | |
| 4438 | core::ptr::non_null::NonNull | byte_add | function | ||
| 4439 | core::ptr::non_null::NonNull | byte_offset | function | ||
| 4440 | core::ptr::non_null::NonNull | byte_offset_from | function | ||
| 4441 | core::ptr::non_null::NonNull | byte_offset_from_unsigned | function | ||
| 4442 | core::ptr::non_null::NonNull | byte_sub | function | ||
| 4443 | core::ptr::non_null::NonNull | copy_from | function | ||
| 4444 | core::ptr::non_null::NonNull | copy_from_nonoverlapping | function | ||
| 4445 | core::ptr::non_null::NonNull | copy_to | function | ||
| 4446 | core::ptr::non_null::NonNull | copy_to_nonoverlapping | function | ||
| 4447 | core::ptr::non_null::NonNull | drop_in_place | function | ||
| 4448 | core::ptr::non_null::NonNull | get_unchecked_mut | function | ||
| 4449 | core::ptr::non_null::NonNull | new_unchecked | function | `ptr` must be non-null. | |
| 4450 | core::ptr::non_null::NonNull | offset | function | If any of the following conditions are violated, the result is Undefined Behavior: * The computed offset, `count * size_of::<T>()` bytes, must not overflow `isize`. * If the computed offset is non-zero, then `self` must be derived from a pointer to some [allocation], and the entire memory range between `self` and the result must be in bounds of that allocation. In particular, this range must not "wrap around" the edge of the address space. Allocations can never be larger than `isize::MAX` bytes, so if the computed offset stays in bounds of the allocation, it is guaranteed to satisfy the first requirement. This implies, for instance, that `vec.as_ptr().add(vec.len())` (for `vec: Vec<T>`) is always safe. [allocation]: crate::ptr#allocation | |
| 4451 | core::ptr::non_null::NonNull | offset_from | function | 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 as isize - origin as isize) / size_of::<T>()`. [`add`]: #method.add [allocation]: crate::ptr#allocation | |
| 4452 | core::ptr::non_null::NonNull | offset_from_unsigned | function | - 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::MAX` *bytes*. As such, the result of this method will always be less than or equal to `isize::MAX as usize`. | |
| 4453 | core::ptr::non_null::NonNull | read | function | ||
| 4454 | core::ptr::non_null::NonNull | read_unaligned | function | ||
| 4455 | core::ptr::non_null::NonNull | read_volatile | function | ||
| 4456 | core::ptr::non_null::NonNull | replace | function | ||
| 4457 | core::ptr::non_null::NonNull | sub | function | If any of the following conditions are violated, the result is Undefined Behavior: * The computed offset, `count * size_of::<T>()` bytes, must not overflow `isize`. * If the computed offset is non-zero, then `self` must be derived from a pointer to some [allocation], and the entire memory range between `self` and the result must be in bounds of that allocation. In particular, this range must not "wrap around" the edge of the address space. Allocations can never be larger than `isize::MAX` bytes, so if the computed offset stays in bounds of the allocation, it is guaranteed to satisfy the first requirement. This implies, for instance, that `vec.as_ptr().add(vec.len())` (for `vec: Vec<T>`) is always safe. [allocation]: crate::ptr#allocation | |
| 4458 | core::ptr::non_null::NonNull | swap | function | ||
| 4459 | core::ptr::non_null::NonNull | write | function | ||
| 4460 | core::ptr::non_null::NonNull | write_bytes | function | ||
| 4461 | core::ptr::non_null::NonNull | write_unaligned | function | ||
| 4462 | core::ptr::non_null::NonNull | write_volatile | function | ||
| 4463 | core::result::Result | unwrap_err_unchecked | function | Calling this method on an [`Ok`] is *[undefined behavior]*. [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html | |
| 4464 | core::result::Result | unwrap_unchecked | function | Calling this method on an [`Err`] is *[undefined behavior]*. [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html | |
| 4465 | core::slice | GetDisjointMutIndex | trait | If `is_in_bounds()` returns `true` and `is_overlapping()` returns `false`, it must be safe to index the slice with the indices. | |
| 4466 | core::slice | SliceIndex | trait | ||
| 4467 | core::slice | align_to | function | 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. | |
| 4468 | core::slice | align_to_mut | function | 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. | |
| 4469 | core::slice | as_ascii_unchecked | function | Every byte in the slice must be in `0..=127`, or else this is UB. | |
| 4470 | core::slice | as_chunks_unchecked | function | This may only be called when - The slice splits exactly into `N`-element chunks (aka `self.len() % N == 0`). - `N != 0`. | |
| 4471 | core::slice | as_chunks_unchecked_mut | function | This may only be called when - The slice splits exactly into `N`-element chunks (aka `self.len() % N == 0`). - `N != 0`. | |
| 4472 | core::slice | assume_init_drop | function | 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. | |
| 4473 | core::slice | assume_init_mut | function | 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. | |
| 4474 | core::slice | assume_init_ref | function | 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. | |
| 4475 | core::slice | from_mut_ptr_range | function | 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. | |
| 4476 | core::slice | from_ptr_range | function | 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. | |
| 4477 | core::slice | from_raw_parts | function | 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](#incorrect-usage) 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`]. | |
| 4478 | core::slice | from_raw_parts_mut | function | 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`]. [valid]: ptr#safety [`NonNull::dangling()`]: ptr::NonNull::dangling | |
| 4479 | core::slice | get_disjoint_unchecked_mut | function | Calling this method with overlapping or out-of-bounds indices is *[undefined behavior]* even if the resulting references are not used. | |
| 4480 | core::slice | get_unchecked | function | 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. [`get`]: slice::get [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html | |
| 4481 | core::slice | get_unchecked_mut | function | 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. [`get_mut`]: slice::get_mut [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html | |
| 4482 | core::slice | split_at_mut_unchecked | function | 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()`. [`split_at_mut`]: slice::split_at_mut [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html | |
| 4483 | core::slice | split_at_unchecked | function | 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()`. [`split_at`]: slice::split_at [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html | |
| 4484 | core::slice | swap_unchecked | function | Calling this method with an out-of-bounds index is *[undefined behavior]*. The caller has to ensure that `a < self.len()` and `b < self.len()`. | |
| 4485 | core::str | as_ascii_unchecked | function | Every character in this string must be ASCII, or else this is UB. | |
| 4486 | core::str | as_bytes_mut | function | The caller must ensure that the content of the slice is valid UTF-8 before the borrow ends and the underlying `str` is used. Use of a `str` whose contents are not valid UTF-8 is undefined behavior. | |
| 4487 | core::str | from_raw_parts | function | ||
| 4488 | core::str | from_raw_parts_mut | function | ||
| 4489 | core::str | from_utf8_unchecked | function | The bytes passed in must be valid UTF-8. | |
| 4490 | core::str | from_utf8_unchecked_mut | function | ||
| 4491 | core::str | get_unchecked | function | Callers of this function are responsible that these preconditions are satisfied: * The starting index must not exceed the ending index; * Indexes must be within bounds of the original slice; * Indexes must lie on UTF-8 sequence boundaries. Failing that, the returned string slice may reference invalid memory or violate the invariants communicated by the `str` type. | |
| 4492 | core::str | get_unchecked_mut | function | Callers of this function are responsible that these preconditions are satisfied: * The starting index must not exceed the ending index; * Indexes must be within bounds of the original slice; * Indexes must lie on UTF-8 sequence boundaries. Failing that, the returned string slice may reference invalid memory or violate the invariants communicated by the `str` type. | |
| 4493 | core::str | next_code_point | function | `bytes` must produce a valid UTF-8-like (UTF-8 or WTF-8) string | |
| 4494 | core::str | slice_mut_unchecked | function | Callers of this function are responsible that three preconditions are satisfied: * `begin` must not exceed `end`. * `begin` and `end` must be byte positions within the string slice. * `begin` and `end` must lie on UTF-8 sequence boundaries. | |
| 4495 | core::str | slice_unchecked | function | Callers of this function are responsible that three preconditions are satisfied: * `begin` must not exceed `end`. * `begin` and `end` must be byte positions within the string slice. * `begin` and `end` must lie on UTF-8 sequence boundaries. | |
| 4496 | core::str::pattern | ReverseSearcher | trait | ||
| 4497 | core::str::pattern | Searcher | trait | ||
| 4498 | core::sync::atomic | AtomicPrimitive | trait | ||
| 4499 | core::sync::atomic::Atomic | from_ptr | function | * `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. [valid]: crate::ptr#safety [Memory model for atomic accesses]: self#memory-model-for-atomic-accesses * `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. [valid]: crate::ptr#safety [Memory model for atomic accesses]: self#memory-model-for-atomic-accesses * `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. [valid]: crate::ptr#safety [Memory model for atomic accesses]: self#memory-model-for-atomic-accesses * `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. [valid]: crate::ptr#safety [Memory model for atomic accesses]: self#memory-model-for-atomic-accesses * `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. [valid]: crate::ptr#safety [Memory model for atomic accesses]: self#memory-model-for-atomic-accesses * `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. [valid]: crate::ptr#safety [Memory model for atomic accesses]: self#memory-model-for-atomic-accesses * `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. [valid]: crate::ptr#safety [Memory model for atomic accesses]: self#memory-model-for-atomic-accesses * `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. [valid]: crate::ptr#safety [Memory model for atomic accesses]: self#memory-model-for-atomic-accesses * `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. [valid]: crate::ptr#safety [Memory model for atomic accesses]: self#memory-model-for-atomic-accesses * `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. [valid]: crate::ptr#safety [Memory model for atomic accesses]: self#memory-model-for-atomic-accesses * `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. [valid]: crate::ptr#safety [Memory model for atomic accesses]: self#memory-model-for-atomic-accesses * `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. [valid]: crate::ptr#safety [Memory model for atomic accesses]: self#memory-model-for-atomic-accesses | |
| 4500 | core::task::wake::LocalWaker | from_raw | function | ||
| 4501 | core::task::wake::LocalWaker | new | function | The behavior of the returned `Waker` is undefined if the contract defined in [`RawWakerVTable`]'s documentation is not upheld. | |
| 4502 | core::task::wake::Waker | from_raw | function | The behavior of the returned `Waker` is undefined if the contract defined in [`RawWaker`]'s and [`RawWakerVTable`]'s documentation is not upheld. (Authors wishing to avoid unsafe code may implement the [`Wake`] trait instead, at the cost of a required heap allocation.) [`Wake`]: ../../alloc/task/trait.Wake.html | |
| 4503 | core::task::wake::Waker | new | function | The behavior of the returned `Waker` is undefined if the contract defined in [`RawWakerVTable`]'s documentation is not upheld. (Authors wishing to avoid unsafe code may implement the [`Wake`] trait instead, at the cost of a required heap allocation.) [`Wake`]: ../../alloc/task/trait.Wake.html | |
| 4504 | core::u128 | unchecked_add | function | This results in undefined behavior when `self + rhs > u128::MAX`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: u128::checked_add [`wrapping_add`]: u128::wrapping_add | |
| 4505 | core::u128 | unchecked_disjoint_bitor | function | Requires that `(self & other) == 0`, otherwise it's immediate UB. Equivalently, requires that `(self | other) == (self + other)`. | |
| 4506 | core::u128 | unchecked_div_exact | function | This results in undefined behavior when `rhs == 0` or `self % rhs != 0`, i.e. when [`checked_div_exact`](Self::checked_div_exact) would return `None`. | |
| 4507 | core::u128 | unchecked_funnel_shl | function | This results in undefined behavior if `n` is greater than or equal to `u128::BITS`, i.e. when [`funnel_shl`](Self::funnel_shl) would panic. | |
| 4508 | core::u128 | unchecked_funnel_shr | function | This results in undefined behavior if `n` is greater than or equal to `u128::BITS`, i.e. when [`funnel_shr`](Self::funnel_shr) would panic. | |
| 4509 | core::u128 | unchecked_mul | function | This results in undefined behavior when `self * rhs > u128::MAX`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: u128::checked_mul [`wrapping_mul`]: u128::wrapping_mul | |
| 4510 | core::u128 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: u128::checked_shl | |
| 4511 | core::u128 | unchecked_shl_exact | function | This results in undefined behavior when `rhs > self.leading_zeros() || rhs >= u128::BITS` i.e. when [`u128::shl_exact`] would return `None`. | |
| 4512 | core::u128 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: u128::checked_shr | |
| 4513 | core::u128 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= u128::BITS` i.e. when [`u128::shr_exact`] would return `None`. | |
| 4514 | core::u128 | unchecked_sub | function | This results in undefined behavior when `self - rhs < u128::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: u128::checked_sub [`wrapping_sub`]: u128::wrapping_sub | |
| 4515 | core::u16 | unchecked_add | function | This results in undefined behavior when `self + rhs > u16::MAX`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: u16::checked_add [`wrapping_add`]: u16::wrapping_add | |
| 4516 | core::u16 | unchecked_disjoint_bitor | function | Requires that `(self & other) == 0`, otherwise it's immediate UB. Equivalently, requires that `(self | other) == (self + other)`. | |
| 4517 | core::u16 | unchecked_div_exact | function | This results in undefined behavior when `rhs == 0` or `self % rhs != 0`, i.e. when [`checked_div_exact`](Self::checked_div_exact) would return `None`. | |
| 4518 | core::u16 | unchecked_funnel_shl | function | This results in undefined behavior if `n` is greater than or equal to `u16::BITS`, i.e. when [`funnel_shl`](Self::funnel_shl) would panic. | |
| 4519 | core::u16 | unchecked_funnel_shr | function | This results in undefined behavior if `n` is greater than or equal to `u16::BITS`, i.e. when [`funnel_shr`](Self::funnel_shr) would panic. | |
| 4520 | core::u16 | unchecked_mul | function | This results in undefined behavior when `self * rhs > u16::MAX`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: u16::checked_mul [`wrapping_mul`]: u16::wrapping_mul | |
| 4521 | core::u16 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: u16::checked_shl | |
| 4522 | core::u16 | unchecked_shl_exact | function | This results in undefined behavior when `rhs > self.leading_zeros() || rhs >= u16::BITS` i.e. when [`u16::shl_exact`] would return `None`. | |
| 4523 | core::u16 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: u16::checked_shr | |
| 4524 | core::u16 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= u16::BITS` i.e. when [`u16::shr_exact`] would return `None`. | |
| 4525 | core::u16 | unchecked_sub | function | This results in undefined behavior when `self - rhs < u16::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: u16::checked_sub [`wrapping_sub`]: u16::wrapping_sub | |
| 4526 | core::u32 | unchecked_add | function | This results in undefined behavior when `self + rhs > u32::MAX`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: u32::checked_add [`wrapping_add`]: u32::wrapping_add | |
| 4527 | core::u32 | unchecked_disjoint_bitor | function | Requires that `(self & other) == 0`, otherwise it's immediate UB. Equivalently, requires that `(self | other) == (self + other)`. | |
| 4528 | core::u32 | unchecked_div_exact | function | This results in undefined behavior when `rhs == 0` or `self % rhs != 0`, i.e. when [`checked_div_exact`](Self::checked_div_exact) would return `None`. | |
| 4529 | core::u32 | unchecked_funnel_shl | function | This results in undefined behavior if `n` is greater than or equal to `u32::BITS`, i.e. when [`funnel_shl`](Self::funnel_shl) would panic. | |
| 4530 | core::u32 | unchecked_funnel_shr | function | This results in undefined behavior if `n` is greater than or equal to `u32::BITS`, i.e. when [`funnel_shr`](Self::funnel_shr) would panic. | |
| 4531 | core::u32 | unchecked_mul | function | This results in undefined behavior when `self * rhs > u32::MAX`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: u32::checked_mul [`wrapping_mul`]: u32::wrapping_mul | |
| 4532 | core::u32 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: u32::checked_shl | |
| 4533 | core::u32 | unchecked_shl_exact | function | This results in undefined behavior when `rhs > self.leading_zeros() || rhs >= u32::BITS` i.e. when [`u32::shl_exact`] would return `None`. | |
| 4534 | core::u32 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: u32::checked_shr | |
| 4535 | core::u32 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= u32::BITS` i.e. when [`u32::shr_exact`] would return `None`. | |
| 4536 | core::u32 | unchecked_sub | function | This results in undefined behavior when `self - rhs < u32::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: u32::checked_sub [`wrapping_sub`]: u32::wrapping_sub | |
| 4537 | core::u64 | unchecked_add | function | This results in undefined behavior when `self + rhs > u64::MAX`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: u64::checked_add [`wrapping_add`]: u64::wrapping_add | |
| 4538 | core::u64 | unchecked_disjoint_bitor | function | Requires that `(self & other) == 0`, otherwise it's immediate UB. Equivalently, requires that `(self | other) == (self + other)`. | |
| 4539 | core::u64 | unchecked_div_exact | function | This results in undefined behavior when `rhs == 0` or `self % rhs != 0`, i.e. when [`checked_div_exact`](Self::checked_div_exact) would return `None`. | |
| 4540 | core::u64 | unchecked_funnel_shl | function | This results in undefined behavior if `n` is greater than or equal to `u64::BITS`, i.e. when [`funnel_shl`](Self::funnel_shl) would panic. | |
| 4541 | core::u64 | unchecked_funnel_shr | function | This results in undefined behavior if `n` is greater than or equal to `u64::BITS`, i.e. when [`funnel_shr`](Self::funnel_shr) would panic. | |
| 4542 | core::u64 | unchecked_mul | function | This results in undefined behavior when `self * rhs > u64::MAX`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: u64::checked_mul [`wrapping_mul`]: u64::wrapping_mul | |
| 4543 | core::u64 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: u64::checked_shl | |
| 4544 | core::u64 | unchecked_shl_exact | function | This results in undefined behavior when `rhs > self.leading_zeros() || rhs >= u64::BITS` i.e. when [`u64::shl_exact`] would return `None`. | |
| 4545 | core::u64 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: u64::checked_shr | |
| 4546 | core::u64 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= u64::BITS` i.e. when [`u64::shr_exact`] would return `None`. | |
| 4547 | core::u64 | unchecked_sub | function | This results in undefined behavior when `self - rhs < u64::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: u64::checked_sub [`wrapping_sub`]: u64::wrapping_sub | |
| 4548 | core::u8 | as_ascii_unchecked | function | This byte must be valid ASCII, or else this is UB. | |
| 4549 | core::u8 | unchecked_add | function | This results in undefined behavior when `self + rhs > u8::MAX`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: u8::checked_add [`wrapping_add`]: u8::wrapping_add | |
| 4550 | core::u8 | unchecked_disjoint_bitor | function | Requires that `(self & other) == 0`, otherwise it's immediate UB. Equivalently, requires that `(self | other) == (self + other)`. | |
| 4551 | core::u8 | unchecked_div_exact | function | This results in undefined behavior when `rhs == 0` or `self % rhs != 0`, i.e. when [`checked_div_exact`](Self::checked_div_exact) would return `None`. | |
| 4552 | core::u8 | unchecked_funnel_shl | function | This results in undefined behavior if `n` is greater than or equal to `u8::BITS`, i.e. when [`funnel_shl`](Self::funnel_shl) would panic. | |
| 4553 | core::u8 | unchecked_funnel_shr | function | This results in undefined behavior if `n` is greater than or equal to `u8::BITS`, i.e. when [`funnel_shr`](Self::funnel_shr) would panic. | |
| 4554 | core::u8 | unchecked_mul | function | This results in undefined behavior when `self * rhs > u8::MAX`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: u8::checked_mul [`wrapping_mul`]: u8::wrapping_mul | |
| 4555 | core::u8 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: u8::checked_shl | |
| 4556 | core::u8 | unchecked_shl_exact | function | This results in undefined behavior when `rhs > self.leading_zeros() || rhs >= u8::BITS` i.e. when [`u8::shl_exact`] would return `None`. | |
| 4557 | core::u8 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: u8::checked_shr | |
| 4558 | core::u8 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= u8::BITS` i.e. when [`u8::shr_exact`] would return `None`. | |
| 4559 | core::u8 | unchecked_sub | function | This results in undefined behavior when `self - rhs < u8::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: u8::checked_sub [`wrapping_sub`]: u8::wrapping_sub | |
| 4560 | core::usize | unchecked_add | function | This results in undefined behavior when `self + rhs > usize::MAX`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: usize::checked_add [`wrapping_add`]: usize::wrapping_add | |
| 4561 | core::usize | unchecked_disjoint_bitor | function | Requires that `(self & other) == 0`, otherwise it's immediate UB. Equivalently, requires that `(self | other) == (self + other)`. | |
| 4562 | core::usize | unchecked_div_exact | function | This results in undefined behavior when `rhs == 0` or `self % rhs != 0`, i.e. when [`checked_div_exact`](Self::checked_div_exact) would return `None`. | |
| 4563 | core::usize | unchecked_funnel_shl | function | This results in undefined behavior if `n` is greater than or equal to `usize::BITS`, i.e. when [`funnel_shl`](Self::funnel_shl) would panic. | |
| 4564 | core::usize | unchecked_funnel_shr | function | This results in undefined behavior if `n` is greater than or equal to `usize::BITS`, i.e. when [`funnel_shr`](Self::funnel_shr) would panic. | |
| 4565 | core::usize | unchecked_mul | function | This results in undefined behavior when `self * rhs > usize::MAX`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: usize::checked_mul [`wrapping_mul`]: usize::wrapping_mul | |
| 4566 | core::usize | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: usize::checked_shl | |
| 4567 | core::usize | unchecked_shl_exact | function | This results in undefined behavior when `rhs > self.leading_zeros() || rhs >= usize::BITS` i.e. when [`usize::shl_exact`] would return `None`. | |
| 4568 | core::usize | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: usize::checked_shr | |
| 4569 | core::usize | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= usize::BITS` i.e. when [`usize::shr_exact`] would return `None`. | |
| 4570 | core::usize | unchecked_sub | function | This results in undefined behavior when `self - rhs < usize::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: usize::checked_sub [`wrapping_sub`]: usize::wrapping_sub | |
| 4571 | std::char | as_ascii_unchecked | function | This char must be within the ASCII range, or else this is UB. | |
| 4572 | std::char | from_u32_unchecked | function | This function is unsafe, as it may construct invalid `char` values. For a safe version of this function, see the [`from_u32`] function. [`from_u32`]: #method.from_u32 | |
| 4573 | std::collections::hash::map::HashMap | get_disjoint_unchecked_mut | function | Calling this method with overlapping keys is *[undefined behavior]* even if the resulting references are not used. [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html | |
| 4574 | std::env | remove_var | function | This function is safe to call in a single-threaded program. This function is also always safe to call on Windows, in single-threaded and multi-threaded programs. In multi-threaded programs on other operating systems, the only safe 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 safe 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: - [Austin Group Bugzilla](https://austingroupbugs.net/view.php?id=188) - [GNU C library Bugzilla](https://sourceware.org/bugzilla/show_bug.cgi?id=15607#c2) To prevent a child process from inheriting an environment variable, you can instead use [`Command::env_remove`] or [`Command::env_clear`]. [`std::net::ToSocketAddrs`]: crate::net::ToSocketAddrs [`Command::env_remove`]: crate::process::Command::env_remove [`Command::env_clear`]: crate::process::Command::env_clear | |
| 4575 | std::env | set_var | function | This function is safe to call in a single-threaded program. This function is also always safe to call on Windows, in single-threaded and multi-threaded programs. In multi-threaded programs on other operating systems, the only safe 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 safe 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: - [Austin Group Bugzilla (for POSIX)](https://austingroupbugs.net/view.php?id=188) - [GNU C library Bugzilla](https://sourceware.org/bugzilla/show_bug.cgi?id=15607#c2) To pass an environment variable to a child process, you can instead use [`Command::env`]. [`std::net::ToSocketAddrs`]: crate::net::ToSocketAddrs [`Command::env`]: crate::process::Command::env | |
| 4576 | std::f128 | to_int_unchecked | function | The value must: * Not be `NaN` * Not be infinite * Be representable in the return type `Int`, after truncating off its fractional part | |
| 4577 | std::f16 | to_int_unchecked | function | The value must: * Not be `NaN` * Not be infinite * Be representable in the return type `Int`, after truncating off its fractional part | |
| 4578 | std::f32 | to_int_unchecked | function | The value must: * Not be `NaN` * Not be infinite * Be representable in the return type `Int`, after truncating off its fractional part | |
| 4579 | std::f64 | to_int_unchecked | function | The value must: * Not be `NaN` * Not be infinite * Be representable in the return type `Int`, after truncating off its fractional part | |
| 4580 | std::ffi::os_str::OsStr | from_encoded_bytes_unchecked | function | 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. | |
| 4581 | std::ffi::os_str::OsString | from_encoded_bytes_unchecked | function | 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. | |
| 4582 | std::i128 | unchecked_add | function | This results in undefined behavior when `self + rhs > i128::MAX` or `self + rhs < i128::MIN`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: i128::checked_add [`wrapping_add`]: i128::wrapping_add | |
| 4583 | std::i128 | unchecked_div_exact | function | 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`. | |
| 4584 | std::i128 | unchecked_mul | function | This results in undefined behavior when `self * rhs > i128::MAX` or `self * rhs < i128::MIN`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: i128::checked_mul [`wrapping_mul`]: i128::wrapping_mul | |
| 4585 | std::i128 | unchecked_neg | function | This results in undefined behavior when `self == i128::MIN`, i.e. when [`checked_neg`] would return `None`. [`checked_neg`]: i128::checked_neg | |
| 4586 | std::i128 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: i128::checked_shl | |
| 4587 | std::i128 | unchecked_shl_exact | function | This results in undefined behavior when `rhs >= self.leading_zeros() && rhs >= self.leading_ones()` i.e. when [`i128::shl_exact`] would return `None`. | |
| 4588 | std::i128 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: i128::checked_shr | |
| 4589 | std::i128 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= i128::BITS` i.e. when [`i128::shr_exact`] would return `None`. | |
| 4590 | std::i128 | unchecked_sub | function | This results in undefined behavior when `self - rhs > i128::MAX` or `self - rhs < i128::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: i128::checked_sub [`wrapping_sub`]: i128::wrapping_sub | |
| 4591 | std::i16 | unchecked_add | function | This results in undefined behavior when `self + rhs > i16::MAX` or `self + rhs < i16::MIN`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: i16::checked_add [`wrapping_add`]: i16::wrapping_add | |
| 4592 | std::i16 | unchecked_div_exact | function | 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`. | |
| 4593 | std::i16 | unchecked_mul | function | This results in undefined behavior when `self * rhs > i16::MAX` or `self * rhs < i16::MIN`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: i16::checked_mul [`wrapping_mul`]: i16::wrapping_mul | |
| 4594 | std::i16 | unchecked_neg | function | This results in undefined behavior when `self == i16::MIN`, i.e. when [`checked_neg`] would return `None`. [`checked_neg`]: i16::checked_neg | |
| 4595 | std::i16 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: i16::checked_shl | |
| 4596 | std::i16 | unchecked_shl_exact | function | This results in undefined behavior when `rhs >= self.leading_zeros() && rhs >= self.leading_ones()` i.e. when [`i16::shl_exact`] would return `None`. | |
| 4597 | std::i16 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: i16::checked_shr | |
| 4598 | std::i16 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= i16::BITS` i.e. when [`i16::shr_exact`] would return `None`. | |
| 4599 | std::i16 | unchecked_sub | function | This results in undefined behavior when `self - rhs > i16::MAX` or `self - rhs < i16::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: i16::checked_sub [`wrapping_sub`]: i16::wrapping_sub | |
| 4600 | std::i32 | unchecked_add | function | This results in undefined behavior when `self + rhs > i32::MAX` or `self + rhs < i32::MIN`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: i32::checked_add [`wrapping_add`]: i32::wrapping_add | |
| 4601 | std::i32 | unchecked_div_exact | function | 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`. | |
| 4602 | std::i32 | unchecked_mul | function | This results in undefined behavior when `self * rhs > i32::MAX` or `self * rhs < i32::MIN`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: i32::checked_mul [`wrapping_mul`]: i32::wrapping_mul | |
| 4603 | std::i32 | unchecked_neg | function | This results in undefined behavior when `self == i32::MIN`, i.e. when [`checked_neg`] would return `None`. [`checked_neg`]: i32::checked_neg | |
| 4604 | std::i32 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: i32::checked_shl | |
| 4605 | std::i32 | unchecked_shl_exact | function | This results in undefined behavior when `rhs >= self.leading_zeros() && rhs >= self.leading_ones()` i.e. when [`i32::shl_exact`] would return `None`. | |
| 4606 | std::i32 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: i32::checked_shr | |
| 4607 | std::i32 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= i32::BITS` i.e. when [`i32::shr_exact`] would return `None`. | |
| 4608 | std::i32 | unchecked_sub | function | This results in undefined behavior when `self - rhs > i32::MAX` or `self - rhs < i32::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: i32::checked_sub [`wrapping_sub`]: i32::wrapping_sub | |
| 4609 | std::i64 | unchecked_add | function | This results in undefined behavior when `self + rhs > i64::MAX` or `self + rhs < i64::MIN`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: i64::checked_add [`wrapping_add`]: i64::wrapping_add | |
| 4610 | std::i64 | unchecked_div_exact | function | 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`. | |
| 4611 | std::i64 | unchecked_mul | function | This results in undefined behavior when `self * rhs > i64::MAX` or `self * rhs < i64::MIN`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: i64::checked_mul [`wrapping_mul`]: i64::wrapping_mul | |
| 4612 | std::i64 | unchecked_neg | function | This results in undefined behavior when `self == i64::MIN`, i.e. when [`checked_neg`] would return `None`. [`checked_neg`]: i64::checked_neg | |
| 4613 | std::i64 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: i64::checked_shl | |
| 4614 | std::i64 | unchecked_shl_exact | function | This results in undefined behavior when `rhs >= self.leading_zeros() && rhs >= self.leading_ones()` i.e. when [`i64::shl_exact`] would return `None`. | |
| 4615 | std::i64 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: i64::checked_shr | |
| 4616 | std::i64 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= i64::BITS` i.e. when [`i64::shr_exact`] would return `None`. | |
| 4617 | std::i64 | unchecked_sub | function | This results in undefined behavior when `self - rhs > i64::MAX` or `self - rhs < i64::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: i64::checked_sub [`wrapping_sub`]: i64::wrapping_sub | |
| 4618 | std::i8 | unchecked_add | function | This results in undefined behavior when `self + rhs > i8::MAX` or `self + rhs < i8::MIN`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: i8::checked_add [`wrapping_add`]: i8::wrapping_add | |
| 4619 | std::i8 | unchecked_div_exact | function | 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`. | |
| 4620 | std::i8 | unchecked_mul | function | This results in undefined behavior when `self * rhs > i8::MAX` or `self * rhs < i8::MIN`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: i8::checked_mul [`wrapping_mul`]: i8::wrapping_mul | |
| 4621 | std::i8 | unchecked_neg | function | This results in undefined behavior when `self == i8::MIN`, i.e. when [`checked_neg`] would return `None`. [`checked_neg`]: i8::checked_neg | |
| 4622 | std::i8 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: i8::checked_shl | |
| 4623 | std::i8 | unchecked_shl_exact | function | This results in undefined behavior when `rhs >= self.leading_zeros() && rhs >= self.leading_ones()` i.e. when [`i8::shl_exact`] would return `None`. | |
| 4624 | std::i8 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: i8::checked_shr | |
| 4625 | std::i8 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= i8::BITS` i.e. when [`i8::shr_exact`] would return `None`. | |
| 4626 | std::i8 | unchecked_sub | function | This results in undefined behavior when `self - rhs > i8::MAX` or `self - rhs < i8::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: i8::checked_sub [`wrapping_sub`]: i8::wrapping_sub | |
| 4627 | std::isize | unchecked_add | function | This results in undefined behavior when `self + rhs > isize::MAX` or `self + rhs < isize::MIN`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: isize::checked_add [`wrapping_add`]: isize::wrapping_add | |
| 4628 | std::isize | unchecked_div_exact | function | 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`. | |
| 4629 | std::isize | unchecked_mul | function | This results in undefined behavior when `self * rhs > isize::MAX` or `self * rhs < isize::MIN`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: isize::checked_mul [`wrapping_mul`]: isize::wrapping_mul | |
| 4630 | std::isize | unchecked_neg | function | This results in undefined behavior when `self == isize::MIN`, i.e. when [`checked_neg`] would return `None`. [`checked_neg`]: isize::checked_neg | |
| 4631 | std::isize | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: isize::checked_shl | |
| 4632 | std::isize | unchecked_shl_exact | function | This results in undefined behavior when `rhs >= self.leading_zeros() && rhs >= self.leading_ones()` i.e. when [`isize::shl_exact`] would return `None`. | |
| 4633 | std::isize | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: isize::checked_shr | |
| 4634 | std::isize | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= isize::BITS` i.e. when [`isize::shr_exact`] would return `None`. | |
| 4635 | std::isize | unchecked_sub | function | This results in undefined behavior when `self - rhs > isize::MAX` or `self - rhs < isize::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: isize::checked_sub [`wrapping_sub`]: isize::wrapping_sub | |
| 4636 | std::os::fd::owned::BorrowedFd | borrow_raw | function | The resource pointed to by `fd` must remain open for the duration of the returned `BorrowedFd`. | |
| 4637 | std::os::windows::io::handle::BorrowedHandle | borrow_raw | function | The resource pointed to by `handle` must be a valid open handle, it must remain open for the duration of the returned `BorrowedHandle`. Note that it *may* have the value `INVALID_HANDLE_VALUE` (-1), which is sometimes a valid handle value. See [here] for the full story. And, it *may* have the value `NULL` (0), which can occur when consoles are detached from processes, or when `windows_subsystem` is used. [here]: https://devblogs.microsoft.com/oldnewthing/20040302-00/?p=40443 | |
| 4638 | std::os::windows::io::handle::HandleOrInvalid | from_raw_handle | function | 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. [here]: https://devblogs.microsoft.com/oldnewthing/20040302-00/?p=40443 | |
| 4639 | std::os::windows::io::handle::HandleOrNull | from_raw_handle | function | 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. [here]: https://devblogs.microsoft.com/oldnewthing/20040302-00/?p=40443 | |
| 4640 | std::os::windows::io::socket::BorrowedSocket | borrow_raw | function | The resource pointed to by `socket` must remain open for the duration of the returned `BorrowedSocket`, and it must not have the value `INVALID_SOCKET`. | |
| 4641 | std::os::windows::process::ProcThreadAttributeListBuilder | raw_attribute | function | 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. | |
| 4642 | std::str | as_ascii_unchecked | function | Every character in this string must be ASCII, or else this is UB. | |
| 4643 | std::str | as_bytes_mut | function | The caller must ensure that the content of the slice is valid UTF-8 before the borrow ends and the underlying `str` is used. Use of a `str` whose contents are not valid UTF-8 is undefined behavior. | |
| 4644 | std::str | from_utf8_unchecked | function | The bytes passed in must be valid UTF-8. | |
| 4645 | std::str | from_utf8_unchecked_mut | function | ||
| 4646 | std::str | get_unchecked | function | Callers of this function are responsible that these preconditions are satisfied: * The starting index must not exceed the ending index; * Indexes must be within bounds of the original slice; * Indexes must lie on UTF-8 sequence boundaries. Failing that, the returned string slice may reference invalid memory or violate the invariants communicated by the `str` type. | |
| 4647 | std::str | get_unchecked_mut | function | Callers of this function are responsible that these preconditions are satisfied: * The starting index must not exceed the ending index; * Indexes must be within bounds of the original slice; * Indexes must lie on UTF-8 sequence boundaries. Failing that, the returned string slice may reference invalid memory or violate the invariants communicated by the `str` type. | |
| 4648 | std::str | slice_mut_unchecked | function | Callers of this function are responsible that three preconditions are satisfied: * `begin` must not exceed `end`. * `begin` and `end` must be byte positions within the string slice. * `begin` and `end` must lie on UTF-8 sequence boundaries. | |
| 4649 | std::str | slice_unchecked | function | Callers of this function are responsible that three preconditions are satisfied: * `begin` must not exceed `end`. * `begin` and `end` must be byte positions within the string slice. * `begin` and `end` must lie on UTF-8 sequence boundaries. | |
| 4650 | std::thread::builder::Builder | spawn_unchecked | function | 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 [`join`][`JoinHandle::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::spawn`][`Builder::spawn`] and [`thread::spawn`] enforce this property statically) | |
| 4651 | std::thread::thread::Thread | from_raw | function | This function is unsafe because improper use may lead to memory unsafety, even if the returned `Thread` is never accessed. Creating a `Thread` from a pointer other than one returned from [`Thread::into_raw`] is **undefined behavior**. Calling this function twice on the same raw pointer can lead to a double-free if both `Thread` instances are dropped. | |
| 4652 | std::u128 | unchecked_add | function | This results in undefined behavior when `self + rhs > u128::MAX`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: u128::checked_add [`wrapping_add`]: u128::wrapping_add | |
| 4653 | std::u128 | unchecked_disjoint_bitor | function | Requires that `(self & other) == 0`, otherwise it's immediate UB. Equivalently, requires that `(self | other) == (self + other)`. | |
| 4654 | std::u128 | unchecked_div_exact | function | This results in undefined behavior when `rhs == 0` or `self % rhs != 0`, i.e. when [`checked_div_exact`](Self::checked_div_exact) would return `None`. | |
| 4655 | std::u128 | unchecked_funnel_shl | function | This results in undefined behavior if `n` is greater than or equal to `u128::BITS`, i.e. when [`funnel_shl`](Self::funnel_shl) would panic. | |
| 4656 | std::u128 | unchecked_funnel_shr | function | This results in undefined behavior if `n` is greater than or equal to `u128::BITS`, i.e. when [`funnel_shr`](Self::funnel_shr) would panic. | |
| 4657 | std::u128 | unchecked_mul | function | This results in undefined behavior when `self * rhs > u128::MAX`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: u128::checked_mul [`wrapping_mul`]: u128::wrapping_mul | |
| 4658 | std::u128 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: u128::checked_shl | |
| 4659 | std::u128 | unchecked_shl_exact | function | This results in undefined behavior when `rhs > self.leading_zeros() || rhs >= u128::BITS` i.e. when [`u128::shl_exact`] would return `None`. | |
| 4660 | std::u128 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: u128::checked_shr | |
| 4661 | std::u128 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= u128::BITS` i.e. when [`u128::shr_exact`] would return `None`. | |
| 4662 | std::u128 | unchecked_sub | function | This results in undefined behavior when `self - rhs < u128::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: u128::checked_sub [`wrapping_sub`]: u128::wrapping_sub | |
| 4663 | std::u16 | unchecked_add | function | This results in undefined behavior when `self + rhs > u16::MAX`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: u16::checked_add [`wrapping_add`]: u16::wrapping_add | |
| 4664 | std::u16 | unchecked_disjoint_bitor | function | Requires that `(self & other) == 0`, otherwise it's immediate UB. Equivalently, requires that `(self | other) == (self + other)`. | |
| 4665 | std::u16 | unchecked_div_exact | function | This results in undefined behavior when `rhs == 0` or `self % rhs != 0`, i.e. when [`checked_div_exact`](Self::checked_div_exact) would return `None`. | |
| 4666 | std::u16 | unchecked_funnel_shl | function | This results in undefined behavior if `n` is greater than or equal to `u16::BITS`, i.e. when [`funnel_shl`](Self::funnel_shl) would panic. | |
| 4667 | std::u16 | unchecked_funnel_shr | function | This results in undefined behavior if `n` is greater than or equal to `u16::BITS`, i.e. when [`funnel_shr`](Self::funnel_shr) would panic. | |
| 4668 | std::u16 | unchecked_mul | function | This results in undefined behavior when `self * rhs > u16::MAX`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: u16::checked_mul [`wrapping_mul`]: u16::wrapping_mul | |
| 4669 | std::u16 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: u16::checked_shl | |
| 4670 | std::u16 | unchecked_shl_exact | function | This results in undefined behavior when `rhs > self.leading_zeros() || rhs >= u16::BITS` i.e. when [`u16::shl_exact`] would return `None`. | |
| 4671 | std::u16 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: u16::checked_shr | |
| 4672 | std::u16 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= u16::BITS` i.e. when [`u16::shr_exact`] would return `None`. | |
| 4673 | std::u16 | unchecked_sub | function | This results in undefined behavior when `self - rhs < u16::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: u16::checked_sub [`wrapping_sub`]: u16::wrapping_sub | |
| 4674 | std::u32 | unchecked_add | function | This results in undefined behavior when `self + rhs > u32::MAX`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: u32::checked_add [`wrapping_add`]: u32::wrapping_add | |
| 4675 | std::u32 | unchecked_disjoint_bitor | function | Requires that `(self & other) == 0`, otherwise it's immediate UB. Equivalently, requires that `(self | other) == (self + other)`. | |
| 4676 | std::u32 | unchecked_div_exact | function | This results in undefined behavior when `rhs == 0` or `self % rhs != 0`, i.e. when [`checked_div_exact`](Self::checked_div_exact) would return `None`. | |
| 4677 | std::u32 | unchecked_funnel_shl | function | This results in undefined behavior if `n` is greater than or equal to `u32::BITS`, i.e. when [`funnel_shl`](Self::funnel_shl) would panic. | |
| 4678 | std::u32 | unchecked_funnel_shr | function | This results in undefined behavior if `n` is greater than or equal to `u32::BITS`, i.e. when [`funnel_shr`](Self::funnel_shr) would panic. | |
| 4679 | std::u32 | unchecked_mul | function | This results in undefined behavior when `self * rhs > u32::MAX`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: u32::checked_mul [`wrapping_mul`]: u32::wrapping_mul | |
| 4680 | std::u32 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: u32::checked_shl | |
| 4681 | std::u32 | unchecked_shl_exact | function | This results in undefined behavior when `rhs > self.leading_zeros() || rhs >= u32::BITS` i.e. when [`u32::shl_exact`] would return `None`. | |
| 4682 | std::u32 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: u32::checked_shr | |
| 4683 | std::u32 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= u32::BITS` i.e. when [`u32::shr_exact`] would return `None`. | |
| 4684 | std::u32 | unchecked_sub | function | This results in undefined behavior when `self - rhs < u32::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: u32::checked_sub [`wrapping_sub`]: u32::wrapping_sub | |
| 4685 | std::u64 | unchecked_add | function | This results in undefined behavior when `self + rhs > u64::MAX`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: u64::checked_add [`wrapping_add`]: u64::wrapping_add | |
| 4686 | std::u64 | unchecked_disjoint_bitor | function | Requires that `(self & other) == 0`, otherwise it's immediate UB. Equivalently, requires that `(self | other) == (self + other)`. | |
| 4687 | std::u64 | unchecked_div_exact | function | This results in undefined behavior when `rhs == 0` or `self % rhs != 0`, i.e. when [`checked_div_exact`](Self::checked_div_exact) would return `None`. | |
| 4688 | std::u64 | unchecked_funnel_shl | function | This results in undefined behavior if `n` is greater than or equal to `u64::BITS`, i.e. when [`funnel_shl`](Self::funnel_shl) would panic. | |
| 4689 | std::u64 | unchecked_funnel_shr | function | This results in undefined behavior if `n` is greater than or equal to `u64::BITS`, i.e. when [`funnel_shr`](Self::funnel_shr) would panic. | |
| 4690 | std::u64 | unchecked_mul | function | This results in undefined behavior when `self * rhs > u64::MAX`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: u64::checked_mul [`wrapping_mul`]: u64::wrapping_mul | |
| 4691 | std::u64 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: u64::checked_shl | |
| 4692 | std::u64 | unchecked_shl_exact | function | This results in undefined behavior when `rhs > self.leading_zeros() || rhs >= u64::BITS` i.e. when [`u64::shl_exact`] would return `None`. | |
| 4693 | std::u64 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: u64::checked_shr | |
| 4694 | std::u64 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= u64::BITS` i.e. when [`u64::shr_exact`] would return `None`. | |
| 4695 | std::u64 | unchecked_sub | function | This results in undefined behavior when `self - rhs < u64::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: u64::checked_sub [`wrapping_sub`]: u64::wrapping_sub | |
| 4696 | std::u8 | as_ascii_unchecked | function | This byte must be valid ASCII, or else this is UB. | |
| 4697 | std::u8 | unchecked_add | function | This results in undefined behavior when `self + rhs > u8::MAX`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: u8::checked_add [`wrapping_add`]: u8::wrapping_add | |
| 4698 | std::u8 | unchecked_disjoint_bitor | function | Requires that `(self & other) == 0`, otherwise it's immediate UB. Equivalently, requires that `(self | other) == (self + other)`. | |
| 4699 | std::u8 | unchecked_div_exact | function | This results in undefined behavior when `rhs == 0` or `self % rhs != 0`, i.e. when [`checked_div_exact`](Self::checked_div_exact) would return `None`. | |
| 4700 | std::u8 | unchecked_funnel_shl | function | This results in undefined behavior if `n` is greater than or equal to `u8::BITS`, i.e. when [`funnel_shl`](Self::funnel_shl) would panic. | |
| 4701 | std::u8 | unchecked_funnel_shr | function | This results in undefined behavior if `n` is greater than or equal to `u8::BITS`, i.e. when [`funnel_shr`](Self::funnel_shr) would panic. | |
| 4702 | std::u8 | unchecked_mul | function | This results in undefined behavior when `self * rhs > u8::MAX`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: u8::checked_mul [`wrapping_mul`]: u8::wrapping_mul | |
| 4703 | std::u8 | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: u8::checked_shl | |
| 4704 | std::u8 | unchecked_shl_exact | function | This results in undefined behavior when `rhs > self.leading_zeros() || rhs >= u8::BITS` i.e. when [`u8::shl_exact`] would return `None`. | |
| 4705 | std::u8 | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: u8::checked_shr | |
| 4706 | std::u8 | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= u8::BITS` i.e. when [`u8::shr_exact`] would return `None`. | |
| 4707 | std::u8 | unchecked_sub | function | This results in undefined behavior when `self - rhs < u8::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: u8::checked_sub [`wrapping_sub`]: u8::wrapping_sub | |
| 4708 | std::usize | unchecked_add | function | This results in undefined behavior when `self + rhs > usize::MAX`, i.e. when [`checked_add`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_add`]: usize::checked_add [`wrapping_add`]: usize::wrapping_add | |
| 4709 | std::usize | unchecked_disjoint_bitor | function | Requires that `(self & other) == 0`, otherwise it's immediate UB. Equivalently, requires that `(self | other) == (self + other)`. | |
| 4710 | std::usize | unchecked_div_exact | function | This results in undefined behavior when `rhs == 0` or `self % rhs != 0`, i.e. when [`checked_div_exact`](Self::checked_div_exact) would return `None`. | |
| 4711 | std::usize | unchecked_funnel_shl | function | This results in undefined behavior if `n` is greater than or equal to `usize::BITS`, i.e. when [`funnel_shl`](Self::funnel_shl) would panic. | |
| 4712 | std::usize | unchecked_funnel_shr | function | This results in undefined behavior if `n` is greater than or equal to `usize::BITS`, i.e. when [`funnel_shr`](Self::funnel_shr) would panic. | |
| 4713 | std::usize | unchecked_mul | function | This results in undefined behavior when `self * rhs > usize::MAX`, i.e. when [`checked_mul`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_mul`]: usize::checked_mul [`wrapping_mul`]: usize::wrapping_mul | |
| 4714 | std::usize | unchecked_shl | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shl`] would return `None`. [`checked_shl`]: usize::checked_shl | |
| 4715 | std::usize | unchecked_shl_exact | function | This results in undefined behavior when `rhs > self.leading_zeros() || rhs >= usize::BITS` i.e. when [`usize::shl_exact`] would return `None`. | |
| 4716 | std::usize | unchecked_shr | function | This results in undefined behavior if `rhs` is larger than or equal to the number of bits in `self`, i.e. when [`checked_shr`] would return `None`. [`checked_shr`]: usize::checked_shr | |
| 4717 | std::usize | unchecked_shr_exact | function | This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >= usize::BITS` i.e. when [`usize::shr_exact`] would return `None`. | |
| 4718 | std::usize | unchecked_sub | function | This results in undefined behavior when `self - rhs < usize::MIN`, i.e. when [`checked_sub`] would return `None`. [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked [`checked_sub`]: usize::checked_sub [`wrapping_sub`]: usize::wrapping_sub |