src/stdarch/crates/core_arch/src/simd.rs

   1 //! Internal `#[repr(simd)]` types
   2
   3 #![allow(non_camel_case_types)]
   4
   5 macro_rules! simd_ty {
   6     ($id:ident [$ety:ident]: $($elem_ty:ident),* | $($elem_name:ident),*) => {
   7         #[repr(simd)]
   8         #[derive(Copy, Clone, Debug, PartialEq)]
   9         pub(crate) struct $id($(pub $elem_ty),*);
  10
  11         #[allow(clippy::use_self)]
  12         impl $id {
  13             #[inline]
  14             pub(crate) const fn new($($elem_name: $elem_ty),*) -> Self {
  15                 $id($($elem_name),*)
  16             }
  17             // FIXME: Workaround rust@60637
  18             #[inline(always)]
  19             pub(crate) const fn splat(value: $ety) -> Self {
  20                 $id($({
  21                     #[allow(non_camel_case_types, dead_code)]
  22                     struct $elem_name;
  23                     value
  24                 }),*)
  25             }
  26
  27             // FIXME: Workaround rust@60637
  28             #[inline(always)]
  29             pub(crate) fn extract(self, index: usize) -> $ety {
  30                 unsafe {
  31                     crate::core_arch::simd_llvm::simd_extract(self, index as u32)
  32                 }
  33             }
  34         }
  35     }
  36 }
  37
  38 macro_rules! simd_m_ty {
  39     ($id:ident [$ety:ident]: $($elem_ty:ident),* | $($elem_name:ident),*) => {
  40         #[repr(simd)]
  41         #[derive(Copy, Clone, Debug, PartialEq)]
  42         pub(crate) struct $id($(pub $elem_ty),*);
  43
  44         #[allow(clippy::use_self)]
  45         impl $id {
  46             #[inline]
  47             const fn bool_to_internal(x: bool) -> $ety {
  48                 [0 as $ety, !(0 as $ety)][x as usize]
  49             }
  50
  51             #[inline]
  52             pub(crate) const fn new($($elem_name: bool),*) -> Self {
  53                 $id($(Self::bool_to_internal($elem_name)),*)
  54             }
  55
  56             // FIXME: Workaround rust@60637
  57             #[inline(always)]
  58             pub(crate) const fn splat(value: bool) -> Self {
  59                 $id($({
  60                     #[allow(non_camel_case_types, dead_code)]
  61                     struct $elem_name;
  62                     Self::bool_to_internal(value)
  63                 }),*)
  64             }
  65
  66             // FIXME: Workaround rust@60637
  67             #[inline(always)]
  68             pub(crate) fn extract(self, index: usize) -> bool {
  69                 let r: $ety = unsafe {
  70                     crate::core_arch::simd_llvm::simd_extract(self, index as u32)
  71                 };
  72                 r != 0
  73             }
  74         }
  75     }
  76 }
  77
  78 // 16-bit wide types:
  79
  80 simd_ty!(u8x2[u8]: u8, u8 | x0, x1);
  81 simd_ty!(i8x2[i8]: i8, i8 | x0, x1);
  82
  83 // 32-bit wide types:
  84
  85 simd_ty!(u8x4[u8]: u8, u8, u8, u8 | x0, x1, x2, x3);
  86 simd_ty!(u16x2[u16]: u16, u16 | x0, x1);
  87
  88 simd_ty!(i8x4[i8]: i8, i8, i8, i8 | x0, x1, x2, x3);
  89 simd_ty!(i16x2[i16]: i16, i16 | x0, x1);
  90
  91 // 64-bit wide types:
  92
  93 simd_ty!(u8x8[u8]:
  94          u8, u8, u8, u8, u8, u8, u8, u8
  95          | x0, x1, x2, x3, x4, x5, x6, x7);
  96 simd_ty!(u16x4[u16]: u16, u16, u16, u16 | x0, x1, x2, x3);
  97 simd_ty!(u32x2[u32]: u32, u32 | x0, x1);
  98 simd_ty!(u64x1[u64]: u64 | x1);
  99
 100 simd_ty!(i8x8[i8]:
 101          i8, i8, i8, i8, i8, i8, i8, i8
 102          | x0, x1, x2, x3, x4, x5, x6, x7);
 103 simd_ty!(i16x4[i16]: i16, i16, i16, i16 | x0, x1, x2, x3);
 104 simd_ty!(i32x2[i32]: i32, i32 | x0, x1);
 105 simd_ty!(i64x1[i64]: i64 | x1);
 106
 107 simd_ty!(f32x2[f32]: f32, f32 | x0, x1);
 108
 109 // 128-bit wide types:
 110
 111 simd_ty!(u8x16[u8]:
 112          u8, u8, u8, u8, u8, u8, u8, u8,
 113          u8, u8, u8, u8, u8, u8, u8, u8
 114          | x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15
 115 );
 116 simd_ty!(u16x8[u16]:
 117          u16, u16, u16, u16, u16, u16, u16, u16
 118          | x0, x1, x2, x3, x4, x5, x6, x7);
 119 simd_ty!(u32x4[u32]: u32, u32, u32, u32 | x0, x1, x2, x3);
 120 simd_ty!(u64x2[u64]: u64, u64 | x0, x1);
 121
 122 simd_ty!(i8x16[i8]:
 123          i8, i8, i8, i8, i8, i8, i8, i8,
 124          i8, i8, i8, i8, i8, i8, i8, i8
 125          | x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15
 126 );
 127 simd_ty!(i16x8[i16]:
 128          i16, i16, i16, i16, i16, i16, i16, i16
 129          | x0, x1, x2, x3, x4, x5, x6, x7);
 130 simd_ty!(i32x4[i32]: i32, i32, i32, i32 | x0, x1, x2, x3);
 131 simd_ty!(i64x2[i64]: i64, i64 | x0, x1);
 132
 133 simd_ty!(f32x4[f32]: f32, f32, f32, f32 | x0, x1, x2, x3);
 134 simd_ty!(f64x2[f64]: f64, f64 | x0, x1);
 135
 136 simd_m_ty!(m8x16[i8]:
 137            i8, i8, i8, i8, i8, i8, i8, i8,
 138            i8, i8, i8, i8, i8, i8, i8, i8
 139            | x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15
 140 );
 141 simd_m_ty!(m16x8[i16]:
 142            i16, i16, i16, i16, i16, i16, i16, i16
 143            | x0, x1, x2, x3, x4, x5, x6, x7);
 144 simd_m_ty!(m32x4[i32]: i32, i32, i32, i32 | x0, x1, x2, x3);
 145 simd_m_ty!(m64x2[i64]: i64, i64 | x0, x1);
 146
 147 // 256-bit wide types:
 148
 149 simd_ty!(u8x32[u8]:
 150          u8, u8, u8, u8, u8, u8, u8, u8,
 151          u8, u8, u8, u8, u8, u8, u8, u8,
 152          u8, u8, u8, u8, u8, u8, u8, u8,
 153          u8, u8, u8, u8, u8, u8, u8, u8
 154          | x0, x1, x2, x3, x4, x5, x6, x7,
 155          x8, x9, x10, x11, x12, x13, x14, x15,
 156          x16, x17, x18, x19, x20, x21, x22, x23,
 157          x24, x25, x26, x27, x28, x29, x30, x31
 158 );
 159 simd_ty!(u16x16[u16]:
 160          u16, u16, u16, u16, u16, u16, u16, u16,
 161          u16, u16, u16, u16, u16, u16, u16, u16
 162          | x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15
 163 );
 164 simd_ty!(u32x8[u32]:
 165          u32, u32, u32, u32, u32, u32, u32, u32
 166          | x0, x1, x2, x3, x4, x5, x6, x7);
 167 simd_ty!(u64x4[u64]: u64, u64, u64, u64 | x0, x1, x2, x3);
 168
 169 simd_ty!(i8x32[i8]:
 170          i8, i8, i8, i8, i8, i8, i8, i8,
 171          i8, i8, i8, i8, i8, i8, i8, i8,
 172          i8, i8, i8, i8, i8, i8, i8, i8,
 173          i8, i8, i8, i8, i8, i8, i8, i8
 174          | x0, x1, x2, x3, x4, x5, x6, x7,
 175          x8, x9, x10, x11, x12, x13, x14, x15,
 176          x16, x17, x18, x19, x20, x21, x22, x23,
 177          x24, x25, x26, x27, x28, x29, x30, x31
 178 );
 179 simd_ty!(i16x16[i16]:
 180          i16, i16, i16, i16, i16, i16, i16, i16,
 181          i16, i16, i16, i16, i16, i16, i16, i16
 182          | x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15
 183 );
 184 simd_ty!(i32x8[i32]:
 185          i32, i32, i32, i32, i32, i32, i32, i32
 186          | x0, x1, x2, x3, x4, x5, x6, x7);
 187 simd_ty!(i64x4[i64]: i64, i64, i64, i64 | x0, x1, x2, x3);
 188
 189 simd_ty!(f32x8[f32]:
 190          f32, f32, f32, f32, f32, f32, f32, f32 |
 191          x0, x1, x2, x3, x4, x5, x6, x7);
 192
 193 // 512-bit wide types:
 194
 195 simd_ty!(i32x16[i32]:
 196          i32, i32, i32, i32, i32, i32, i32, i32,
 197          i32, i32, i32, i32, i32, i32, i32, i32
 198          | x0, x1, x2, x3, x4, x5, x6, x7,
 199          x8, x9, x10, x11, x12, x13, x14, x15);
 200
 201 simd_ty!(i64x8[i64]:
 202          i64, i64, i64, i64, i64, i64, i64, i64
 203          | x0, x1, x2, x3, x4, x5, x6, x7);