Add pointer vectors and implement a few more traits

Author: calebzulawski

crates/core_simd/src/lib.rs

@@ -9,6 +9,9 @@ mod macros;
 mod masks;
 pub use masks::*;
 
+mod pointers;
+pub use pointers::*;
+
 mod vectors_u8;
 pub use vectors_u8::*;
 mod vectors_u16;

crates/core_simd/src/macros.rs

@@ -96,7 +96,7 @@ macro_rules! call_counting_args {
     { 2 => $mac:path => $($args:tt)* } => {
         $mac! {
             $($args)*
-            v1 v2
+            v0 v1
         }
     };
     { 4 => $mac:path => $($args:tt)* } => {
@@ -135,6 +135,57 @@ macro_rules! call_counting_args {
     };
 }
 
+/// Calls the macro `$mac` with the specified `$args` followed by counting values from 0 to the
+/// specified value.
+macro_rules! call_counting_values {
+    { 1 => $mac:path => $($args:tt)* } => {
+        $mac! {
+            $($args)*
+            0
+        }
+    };
+    { 2 => $mac:path => $($args:tt)* } => {
+        $mac! {
+            $($args)*
+            0 1
+        }
+    };
+    { 4 => $mac:path => $($args:tt)* } => {
+        $mac! {
+            $($args)*
+            0 1 2 3
+        }
+    };
+    { 8 => $mac:path => $($args:tt)* } => {
+        $mac! {
+            $($args)*
+            0 1 2 3 4 5 6 7
+        }
+    };
+    { 16 => $mac:path => $($args:tt)* } => {
+        $mac! {
+            $($args)*
+            0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+        }
+    };
+    { 32 => $mac:path => $($args:tt)* } => {
+        $mac! {
+            $($args)*
+            0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
+            16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
+        }
+    };
+    { 64 => $mac:path => $($args:tt)* } => {
+        $mac! {
+            $($args)*
+            0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
+            16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
+            32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
+            48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
+        }
+    };
+}
+
 /// Implements common traits on the specified vector `$name`, holding multiple `$lanes` of `$type`.
 macro_rules! base_vector_traits {
     { $name:path => [$type:ty; $lanes:literal] } => {
@@ -233,7 +284,7 @@ macro_rules! define_mask_vector {
     { def $(#[$attr:meta])* | $name:ident | $($itype:ty)* } => {
         $(#[$attr])*
         #[allow(non_camel_case_types)]
-        #[derive(Copy, Clone, Debug, Default, PartialEq, PartialOrd)]
+        #[derive(Copy, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
         #[repr(simd)]
         pub struct $name($($itype),*);
     };

crates/core_simd/src/pointers.rs

@@ -0,0 +1,116 @@
+use core::marker::PhantomData;
+
+use crate::vectors_isize::*;
+
+macro_rules! define_pointer_vector {
+    { $(#[$attr:meta])* $name:ident => $underlying:ty => $lanes:tt, $mut:ident } => {
+        $(#[$attr])*
+        #[allow(non_camel_case_types)]
+        #[repr(C)]
+        pub struct $name<T>($underlying, PhantomData<T>);
+
+        impl<T> Copy for $name<T> {}
+
+        impl<T> Clone for $name<T> {
+            #[inline]
+            fn clone(&self) -> Self {
+                *self
+            }
+        }
+
+        impl<T> core::cmp::PartialEq for $name<T> {
+            #[inline]
+            fn eq(&self, other: &Self) -> bool {
+                self.0.eq(&other.0)
+            }
+        }
+
+        impl<T> core::cmp::Eq for $name<T> {}
+
+        impl<T> core::cmp::PartialOrd for $name<T> {
+            #[inline]
+            fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+                self.0.partial_cmp(&other.0)
+            }
+        }
+
+        impl<T> core::cmp::Ord for $name<T> {
+            fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+                self.0.cmp(&other.0)
+            }
+        }
+
+        call_counting_values! { $lanes => define_pointer_vector => debug $name | *$mut T | }
+
+        impl<T> $name<T> {
+            /// Construct a vector by setting all lanes to the given value.
+            #[inline]
+            pub fn splat(value: *$mut T) -> Self {
+                Self(<$underlying>::splat(value as isize), PhantomData)
+            }
+            call_counting_args! { $lanes => define_pointer_vector => new $underlying | *$mut T | }
+        }
+
+        // array references
+        impl<T> AsRef<[*$mut T; $lanes]> for $name<T> {
+            #[inline]
+            fn as_ref(&self) -> &[*$mut T; $lanes] {
+                unsafe { &*(self as *const _ as *const _) }
+            }
+        }
+
+        impl<T> AsMut<[*$mut T; $lanes]> for $name<T> {
+            #[inline]
+            fn as_mut(&mut self) -> &mut [*$mut T; $lanes] {
+                unsafe { &mut *(self as *mut _ as *mut _) }
+            }
+        }
+
+        // slice references
+        impl<T> AsRef<[*$mut T]> for $name<T> {
+            #[inline]
+            fn as_ref(&self) -> &[*$mut T] {
+                AsRef::<[*$mut T; $lanes]>::as_ref(self)
+            }
+        }
+
+        impl<T> AsMut<[*$mut T]> for $name<T> {
+            #[inline]
+            fn as_mut(&mut self) -> &mut [*$mut T] {
+                AsMut::<[*$mut T; $lanes]>::as_mut(self)
+            }
+        }
+
+        // splat
+        impl<T> From<*$mut T> for $name<T> {
+            #[inline]
+            fn from(value: *$mut T) -> Self {
+                Self::splat(value)
+            }
+        }
+    };
+    { new $underlying:ty | $type:ty | $($var:ident)* } => {
+        /// Construct a vector by setting each lane to the given values.
+        #[allow(clippy::too_many_arguments)]
+        #[inline]
+        pub fn new($($var: $type),*) -> Self {
+            Self(<$underlying>::new($($var as isize),*), PhantomData)
+        }
+    };
+    { debug $name:ident | $type:ty | $($index:tt)* } => {
+        impl<T> core::fmt::Debug for $name<T> {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                f.debug_tuple(stringify!($name))
+                    $(.field(&(AsRef::<[isize]>::as_ref(&self.0)[$index] as $type)))*
+                    .finish()
+            }
+        }
+    }
+}
+
+define_pointer_vector! { #[doc = "Vector of two mutable pointers"] mptrx2 => isizex2 => 2, mut }
+define_pointer_vector! { #[doc = "Vector of four mutable pointers"] mptrx4 => isizex4 => 4, mut }
+define_pointer_vector! { #[doc = "Vector of eight mutable pointers"] mptrx8 => isizex8 => 8, mut }
+define_pointer_vector! { #[doc = "Vector of two const pointers"] cptrx2 => isizex2 => 2, const }
+define_pointer_vector! { #[doc = "Vector of four const pointers"] cptrx4 => isizex4 => 4, const }
+define_pointer_vector! { #[doc = "Vector of eight const pointers"] cptrx8 => isizex8 => 8, const }

crates/core_simd/src/vectors_i128.rs

@@ -1,10 +1,12 @@
 define_vector! {
     #[doc = "Vector of two `i128` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i128x2([i128; 2]);
 }
 
 define_vector! {
     #[doc = "Vector of four `i128` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i128x4([i128; 4]);
 }
 

crates/core_simd/src/vectors_i16.rs

@@ -1,25 +1,30 @@
 define_vector! {
     #[doc = "Vector of two `i16` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i16x2([i16; 2]);
 }
 
 define_vector! {
     #[doc = "Vector of four `i16` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i16x4([i16; 4]);
 }
 
 define_vector! {
     #[doc = "Vector of eight `i16` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i16x8([i16; 8]);
 }
 
 define_vector! {
     #[doc = "Vector of 16 `i16` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i16x16([i16; 16]);
 }
 
 define_vector! {
     #[doc = "Vector of 32 `i16` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i16x32([i16; 32]);
 }
 

crates/core_simd/src/vectors_i32.rs

@@ -1,20 +1,24 @@
 define_vector! {
     #[doc = "Vector of two `i32` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i32x2([i32; 2]);
 }
 
 define_vector! {
     #[doc = "Vector of four `i32` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i32x4([i32; 4]);
 }
 
 define_vector! {
     #[doc = "Vector of eight `i32` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i32x8([i32; 8]);
 }
 
 define_vector! {
     #[doc = "Vector of 16 `i32` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i32x16([i32; 16]);
 }
 

crates/core_simd/src/vectors_i64.rs

@@ -1,15 +1,18 @@
 define_vector! {
     #[doc = "Vector of two `i64` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i64x2([i64; 2]);
 }
 
 define_vector! {
     #[doc = "Vector of four `i64` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i64x4([i64; 4]);
 }
 
 define_vector! {
     #[doc = "Vector of eight `i64` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i64x8([i64; 8]);
 }
 

crates/core_simd/src/vectors_i8.rs

@@ -1,30 +1,36 @@
 define_vector! {
     #[doc = "Vector of two `i8` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i8x2([i8; 2]);
 }
 
 define_vector! {
     #[doc = "Vector of four `i8` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i8x4([i8; 4]);
 }
 
 define_vector! {
     #[doc = "Vector of eight `i8` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i8x8([i8; 8]);
 }
 
 define_vector! {
     #[doc = "Vector of 16 `i8` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i8x16([i8; 16]);
 }
 
 define_vector! {
     #[doc = "Vector of 32 `i8` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i8x32([i8; 32]);
 }
 
 define_vector! {
     #[doc = "Vector of 64 `i8` values"]
+    #[derive(Eq, Ord, Hash)]
     struct i8x64([i8; 64]);
 }
 

crates/core_simd/src/vectors_isize.rs

@@ -1,15 +1,18 @@
 define_vector! {
     #[doc = "Vector of two `isize` values"]
+    #[derive(Eq, Ord, Hash)]
     struct isizex2([isize; 2]);
 }
 
 define_vector! {
     #[doc = "Vector of four `isize` values"]
+    #[derive(Eq, Ord, Hash)]
     struct isizex4([isize; 4]);
 }
 
 define_vector! {
     #[doc = "Vector of eight `isize` values"]
+    #[derive(Eq, Ord, Hash)]
     struct isizex8([isize; 8]);
 }
 

crates/core_simd/src/vectors_u128.rs

@@ -1,10 +1,12 @@
 define_vector! {
     #[doc = "Vector of two `u128` values"]
+    #[derive(Eq, Ord, Hash)]
     struct u128x2([u128; 2]);
 }
 
 define_vector! {
     #[doc = "Vector of four `u128` values"]
+    #[derive(Eq, Ord, Hash)]
     struct u128x4([u128; 4]);
 }