Skip to main content

libzstd_rs_sys/lib/common/
mem.rs

1use core::ffi::{c_uint, c_void};
2use core::mem;
3
4use libc::size_t;
5
6#[inline]
7pub(crate) fn MEM_32bits() -> c_uint {
8    (::core::mem::size_of::<usize>() == 4) as _
9}
10#[inline]
11pub(crate) fn MEM_64bits() -> c_uint {
12    (::core::mem::size_of::<usize>() == 8) as _
13}
14
15#[inline]
16pub(crate) fn MEM_isLittleEndian() -> c_uint {
17    cfg!(target_endian = "little") as _
18}
19
20#[inline]
21pub(crate) unsafe fn MEM_read16(ptr: *const c_void) -> u16 {
22    ptr.cast::<u16>().read_unaligned()
23}
24#[inline]
25pub(crate) unsafe fn MEM_read32(ptr: *const c_void) -> u32 {
26    ptr.cast::<u32>().read_unaligned()
27}
28#[inline]
29pub(crate) unsafe fn MEM_read64(ptr: *const c_void) -> u64 {
30    ptr.cast::<u64>().read_unaligned()
31}
32#[inline]
33pub(crate) unsafe fn MEM_readST(ptr: *const c_void) -> size_t {
34    ptr.cast::<usize>().read_unaligned()
35}
36
37#[inline]
38pub(crate) unsafe fn MEM_write16(memPtr: *mut c_void, value: u16) {
39    memPtr.cast::<u16>().write_unaligned(value)
40}
41#[inline]
42pub(crate) unsafe fn MEM_write32(memPtr: *mut c_void, value: u32) {
43    memPtr.cast::<u32>().write_unaligned(value)
44}
45#[inline]
46pub(crate) unsafe fn MEM_write64(memPtr: *mut c_void, value: u64) {
47    memPtr.cast::<u64>().write_unaligned(value)
48}
49
50#[inline]
51pub(crate) fn MEM_swap16(in_0: u16) -> u16 {
52    in_0.swap_bytes()
53}
54#[inline]
55pub(crate) fn MEM_swap32(in_0: u32) -> u32 {
56    in_0.swap_bytes()
57}
58#[inline]
59pub(crate) fn MEM_swap64(in_0: u64) -> u64 {
60    in_0.swap_bytes()
61}
62
63#[inline]
64pub(crate) unsafe fn MEM_readLE16(memPtr: *const c_void) -> u16 {
65    if cfg!(target_endian = "little") {
66        MEM_read16(memPtr)
67    } else {
68        let p = memPtr as *const u8;
69        (*p.offset(0) as core::ffi::c_int + ((*p.offset(1) as core::ffi::c_int) << 8)) as u16
70    }
71}
72
73#[inline]
74pub(crate) unsafe fn MEM_writeLE16(memPtr: *mut c_void, val32: u16) {
75    if cfg!(target_endian = "little") {
76        MEM_write16(memPtr, val32);
77    } else {
78        MEM_write16(memPtr, MEM_swap16(val32));
79    };
80}
81
82#[inline]
83pub unsafe fn MEM_readLE24(memPtr: *const c_void) -> u32 {
84    (MEM_readLE16(memPtr) as u32).wrapping_add((*(memPtr as *const u8).offset(2) as u32) << 16)
85}
86
87#[inline]
88pub(crate) unsafe fn MEM_writeLE24(memPtr: *mut c_void, val: u32) {
89    MEM_writeLE16(memPtr, val as u16);
90    *(memPtr as *mut u8).offset(2) = (val >> 16) as u8;
91}
92
93#[inline]
94pub unsafe fn MEM_readLE32(memPtr: *const c_void) -> u32 {
95    if cfg!(target_endian = "little") {
96        MEM_read32(memPtr)
97    } else {
98        MEM_swap32(MEM_read32(memPtr))
99    }
100}
101
102#[inline]
103pub(crate) unsafe fn MEM_writeLE32(memPtr: *mut c_void, val32: u32) {
104    if cfg!(target_endian = "little") {
105        MEM_write32(memPtr, val32);
106    } else {
107        MEM_write32(memPtr, MEM_swap32(val32));
108    };
109}
110
111#[inline]
112pub(crate) unsafe fn MEM_readLE64(memPtr: *const c_void) -> u64 {
113    if cfg!(target_endian = "little") {
114        MEM_read64(memPtr)
115    } else {
116        MEM_swap64(MEM_read64(memPtr))
117    }
118}
119
120#[inline]
121pub(crate) unsafe fn MEM_writeLE64(memPtr: *mut c_void, val64: u64) {
122    if cfg!(target_endian = "little") {
123        MEM_write64(memPtr, val64);
124    } else {
125        MEM_write64(memPtr, MEM_swap64(val64));
126    };
127}
128
129#[inline]
130pub(crate) unsafe fn MEM_readLEST(memPtr: *const c_void) -> size_t {
131    match mem::size_of::<size_t>() {
132        4 => MEM_readLE32(memPtr) as size_t,
133        8 => MEM_readLE64(memPtr) as size_t,
134        _ => unreachable!(),
135    }
136}
137
138#[inline]
139pub(crate) unsafe fn MEM_writeLEST(memPtr: *mut c_void, val: size_t) {
140    match mem::size_of::<size_t>() {
141        4 => MEM_writeLE32(memPtr, val as u32),
142        8 => MEM_writeLE64(memPtr, val as u64),
143        _ => unreachable!(),
144    }
145}
146
147const _: () = {
148    assert!(mem::size_of::<size_t>() == 4 || mem::size_of::<size_t>() == 8);
149};