use std::alloc::Layout;
use std::any::TypeId;
use std::num::*;
use std::sync::OnceLock;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NativeTypeLayout {
pub rust_type_id: TypeId,
pub size: usize,
pub align: usize,
pub kind: NativeTypeKind,
}
impl NativeTypeLayout {
pub fn of<T: 'static>(size: usize, align: usize, kind: NativeTypeKind) -> Self {
Self {
rust_type_id: TypeId::of::<T>(),
size,
align,
kind,
}
}
pub fn for_type<T: 'static>(kind: NativeTypeKind) -> Self {
Self::of::<T>(std::mem::size_of::<T>(), std::mem::align_of::<T>(), kind)
}
pub fn structure<T: 'static>(fields: Vec<NativeField>) -> Self {
Self::for_type::<T>(NativeTypeKind::Structure { fields })
}
pub fn enum_type<T: 'static>(layout: NativeEnumLayout) -> Self {
Self::for_type::<T>(NativeTypeKind::Enum(layout))
}
pub fn opaque<T: 'static>() -> Self {
Self::for_type::<T>(NativeTypeKind::Opaque)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NativePassMode {
Indirect,
Registers(Vec<NativeRegisterChunk>),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct NativeRegisterChunk {
pub offset: usize,
pub class: NativeRegisterClass,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum NativeRegisterClass {
Integer { bits: u16 },
Float { bits: u16 },
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NativeTypeKind {
Scalar {
bits: u16,
signed: bool,
},
Bytes,
Structure {
fields: Vec<NativeField>,
},
Enum(NativeEnumLayout),
Opaque,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NativeField {
pub index: u32,
pub offset: usize,
pub layout: &'static NativeTypeLayout,
}
impl NativeField {
pub const fn new(index: u32, offset: usize, layout: &'static NativeTypeLayout) -> Self {
Self {
index,
offset,
layout,
}
}
pub fn of<T: NativeAbi>(index: u32, offset: usize) -> Self {
Self::new(index, offset, T::native_layout())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NativeEnumLayout {
pub variants: Vec<NativeEnumVariant>,
pub tag: NativeEnumTag,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NativeEnumVariant {
pub index: u32,
pub payload: Option<&'static NativeTypeLayout>,
pub payload_offset: Option<usize>,
}
impl NativeEnumVariant {
pub const fn unit(index: u32) -> Self {
Self {
index,
payload: None,
payload_offset: None,
}
}
pub const fn payload(
index: u32,
payload: &'static NativeTypeLayout,
payload_offset: usize,
) -> Self {
Self {
index,
payload: Some(payload),
payload_offset: Some(payload_offset),
}
}
}
impl NativeEnumLayout {
pub fn direct(
variants: Vec<NativeEnumVariant>,
offset: usize,
bits: u16,
signed: bool,
variant_tags: Vec<u128>,
) -> Self {
Self {
variants,
tag: NativeEnumTag::Direct {
offset,
bits,
signed,
variant_tags,
},
}
}
pub fn niche(
variants: Vec<NativeEnumVariant>,
offset: usize,
bits: u16,
niche_start: u128,
niche_variants: std::ops::RangeInclusive<u32>,
data_variant: u32,
) -> Self {
Self {
variants,
tag: NativeEnumTag::Niche {
offset,
bits,
niche_start,
niche_variants,
data_variant,
},
}
}
pub fn single(variant: NativeEnumVariant) -> Self {
Self {
variants: vec![variant],
tag: NativeEnumTag::SingleVariant,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NativeEnumTag {
Direct {
offset: usize,
bits: u16,
signed: bool,
variant_tags: Vec<u128>,
},
Niche {
offset: usize,
bits: u16,
niche_start: u128,
niche_variants: std::ops::RangeInclusive<u32>,
data_variant: u32,
},
SingleVariant,
}
pub unsafe trait NativeAbi: 'static {
fn native_layout() -> &'static NativeTypeLayout;
fn native_pass_mode() -> NativePassMode {
NativePassMode::Indirect
}
}
#[repr(transparent)]
#[derive(Clone, PartialEq, Eq, Hash)]
pub struct LehitValue<const SIZE: usize> {
bytes: [u8; SIZE],
}
impl<const SIZE: usize> LehitValue<SIZE> {
pub const fn from_bytes(bytes: [u8; SIZE]) -> Self {
Self { bytes }
}
pub const fn as_bytes(&self) -> &[u8; SIZE] {
&self.bytes
}
pub fn as_bytes_mut(&mut self) -> &mut [u8; SIZE] {
&mut self.bytes
}
pub const fn into_bytes(self) -> [u8; SIZE] {
self.bytes
}
}
impl<const SIZE: usize> std::fmt::Debug for LehitValue<SIZE> {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter
.debug_tuple("LehitValue")
.field(&self.bytes)
.finish()
}
}
unsafe impl<const SIZE: usize> NativeAbi for LehitValue<SIZE> {
fn native_layout() -> &'static NativeTypeLayout {
static LAYOUTS: OnceLock<
std::sync::Mutex<std::collections::HashMap<usize, &'static NativeTypeLayout>>,
> = OnceLock::new();
let layouts = LAYOUTS.get_or_init(Default::default);
let mut layouts = layouts.lock().unwrap_or_else(|error| error.into_inner());
*layouts.entry(SIZE).or_insert_with(|| {
Box::leak(Box::new(NativeTypeLayout {
rust_type_id: TypeId::of::<LehitValue<SIZE>>(),
size: SIZE,
align: 1,
kind: NativeTypeKind::Bytes,
}))
})
}
}
macro_rules! scalar_abi {
($type:ty, $signed:expr) => {
unsafe impl NativeAbi for $type {
fn native_layout() -> &'static NativeTypeLayout {
static LAYOUT: OnceLock<NativeTypeLayout> = OnceLock::new();
LAYOUT.get_or_init(|| NativeTypeLayout {
rust_type_id: TypeId::of::<$type>(),
size: Layout::new::<$type>().size(),
align: Layout::new::<$type>().align(),
kind: NativeTypeKind::Scalar {
bits: (Layout::new::<$type>().size() * 8) as u16,
signed: $signed,
},
})
}
}
};
}
scalar_abi!(u8, false);
scalar_abi!(u16, false);
scalar_abi!(u32, false);
scalar_abi!(u64, false);
scalar_abi!(u128, false);
scalar_abi!(usize, false);
scalar_abi!(i8, true);
scalar_abi!(i16, true);
scalar_abi!(i32, true);
scalar_abi!(i64, true);
scalar_abi!(i128, true);
scalar_abi!(isize, true);
scalar_abi!(f32, true);
scalar_abi!(f64, true);
fn cached_native_layout<T: 'static>(
create: impl FnOnce() -> NativeTypeLayout,
) -> &'static NativeTypeLayout {
static LAYOUTS: OnceLock<
std::sync::Mutex<std::collections::HashMap<TypeId, &'static NativeTypeLayout>>,
> = OnceLock::new();
let layouts = LAYOUTS.get_or_init(Default::default);
let type_id = TypeId::of::<T>();
if let Some(layout) = layouts
.lock()
.unwrap_or_else(|error| error.into_inner())
.get(&type_id)
.copied()
{
return layout;
}
let created = Box::leak(Box::new(create()));
let mut cache = layouts.lock().unwrap_or_else(|error| error.into_inner());
*cache.entry(type_id).or_insert(created)
}
unsafe impl<T: 'static> NativeAbi for *const T {
fn native_layout() -> &'static NativeTypeLayout {
cached_native_layout::<Self>(NativeTypeLayout::opaque::<Self>)
}
fn native_pass_mode() -> NativePassMode {
integer_register_pass_mode(Layout::new::<Self>().size())
}
}
unsafe impl<T: 'static> NativeAbi for *mut T {
fn native_layout() -> &'static NativeTypeLayout {
cached_native_layout::<Self>(NativeTypeLayout::opaque::<Self>)
}
fn native_pass_mode() -> NativePassMode {
integer_register_pass_mode(Layout::new::<Self>().size())
}
}
unsafe impl<T: 'static> NativeAbi for Box<T> {
fn native_layout() -> &'static NativeTypeLayout {
cached_native_layout::<Self>(|| {
NativeTypeLayout::structure::<Self>(vec![NativeField::of::<*mut T>(0, 0)])
})
}
fn native_pass_mode() -> NativePassMode {
integer_register_pass_mode(Layout::new::<Self>().size())
}
}
unsafe impl<T: 'static> NativeAbi for Option<Box<T>> {
fn native_layout() -> &'static NativeTypeLayout {
cached_native_layout::<Self>(|| {
NativeTypeLayout::enum_type::<Self>(NativeEnumLayout::niche(
vec![
NativeEnumVariant::unit(0),
NativeEnumVariant::payload(1, Box::<T>::native_layout(), 0),
],
0,
(Layout::new::<usize>().size() * 8) as u16,
0,
0..=0,
1,
))
})
}
fn native_pass_mode() -> NativePassMode {
integer_register_pass_mode(Layout::new::<Self>().size())
}
}
fn integer_register_pass_mode(size: usize) -> NativePassMode {
if size <= 8 {
NativePassMode::Registers(vec![NativeRegisterChunk {
offset: 0,
class: NativeRegisterClass::Integer {
bits: (size * 8) as u16,
},
}])
} else {
NativePassMode::Indirect
}
}
macro_rules! nonzero_abi {
($($type:ty => $inner:ty),* $(,)?) => {$(
unsafe impl NativeAbi for $type {
fn native_layout() -> &'static NativeTypeLayout {
static LAYOUT: OnceLock<NativeTypeLayout> = OnceLock::new();
LAYOUT.get_or_init(|| NativeTypeLayout::structure::<$type>(vec![
NativeField::of::<$inner>(0, 0),
]))
}
fn native_pass_mode() -> NativePassMode {
integer_register_pass_mode(Layout::new::<Self>().size())
}
}
)*};
}
nonzero_abi!(
NonZeroU8 => u8,
NonZeroU16 => u16,
NonZeroU32 => u32,
NonZeroU64 => u64,
NonZeroU128 => u128,
NonZeroUsize => usize,
NonZeroI8 => i8,
NonZeroI16 => i16,
NonZeroI32 => i32,
NonZeroI64 => i64,
NonZeroI128 => i128,
NonZeroIsize => isize
);
macro_rules! option_nonzero_abi {
($($type:ty => $inner:ty),* $(,)?) => {$(
unsafe impl NativeAbi for Option<$type> {
fn native_layout() -> &'static NativeTypeLayout {
static LAYOUT: OnceLock<NativeTypeLayout> = OnceLock::new();
LAYOUT.get_or_init(|| {
NativeTypeLayout::enum_type::<Option<$type>>(NativeEnumLayout::niche(
vec![
NativeEnumVariant::unit(0),
NativeEnumVariant::payload(1, <$type>::native_layout(), 0),
],
0,
(Layout::new::<$inner>().size() * 8) as u16,
0,
0..=0,
1,
))
})
}
fn native_pass_mode() -> NativePassMode {
integer_register_pass_mode(Layout::new::<Self>().size())
}
}
)*};
}
option_nonzero_abi!(
NonZeroU8 => u8,
NonZeroU16 => u16,
NonZeroU32 => u32,
NonZeroU64 => u64,
NonZeroUsize => usize,
NonZeroI8 => i8,
NonZeroI16 => i16,
NonZeroI32 => i32,
NonZeroI64 => i64,
NonZeroIsize => isize
);
pub fn is_abi_compatible<T: NativeAbi>(expected: &NativeTypeLayout) -> bool {
let actual = T::native_layout();
actual.rust_type_id == expected.rust_type_id
&& actual.size == expected.size
&& actual.align == expected.align
&& actual.kind == expected.kind
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn box_and_non_zero_options_use_rust_zero_niches() {
let boxed = Box::<u32>::native_layout();
assert_eq!(boxed.size, std::mem::size_of::<Box<u32>>());
assert_eq!(boxed.align, std::mem::align_of::<Box<u32>>());
assert!(matches!(boxed.kind, NativeTypeKind::Structure { .. }));
for layout in [
Option::<Box<u32>>::native_layout(),
Option::<NonZeroU32>::native_layout(),
] {
assert_eq!(
layout.size,
match &layout.kind {
NativeTypeKind::Enum(enum_) => enum_
.variants
.iter()
.find_map(|variant| variant.payload.map(|payload| payload.size))
.unwrap(),
_ => panic!("niche option must be an enum"),
}
);
assert!(matches!(
&layout.kind,
NativeTypeKind::Enum(NativeEnumLayout {
tag: NativeEnumTag::Niche {
niche_start: 0,
niche_variants,
data_variant: 1,
..
},
..
}) if niche_variants == &(0..=0)
));
}
let non_zero = NonZeroU32::native_layout();
assert_eq!((non_zero.size, non_zero.align), (4, 4));
assert!(matches!(
&non_zero.kind,
NativeTypeKind::Structure { fields }
if fields.len() == 1
&& fields[0].offset == 0
&& fields[0].layout.rust_type_id == TypeId::of::<u32>()
));
}
#[test]
fn lehit_owned_values_are_transparent_byte_arrays() {
let value = LehitValue::<4>::from_bytes([1, 2, 3, 4]);
assert_eq!(value.as_bytes(), &[1, 2, 3, 4]);
assert_eq!(value.into_bytes(), [1, 2, 3, 4]);
assert_eq!(std::mem::size_of::<LehitValue<4>>(), 4);
assert_eq!(std::mem::align_of::<LehitValue<4>>(), 1);
let layout = LehitValue::<4>::native_layout();
assert_eq!(layout.size, 4);
assert_eq!(layout.align, 1);
assert_eq!(layout.kind, NativeTypeKind::Bytes);
}
#[test]
fn borrowing_a_lehit_value_borrows_the_same_bytes() {
let value = LehitValue::<3>::from_bytes([7, 8, 9]);
let borrowed: &[u8; 3] = value.as_bytes();
assert!(std::ptr::eq(borrowed, value.as_bytes()));
}
}