1use serde::Serialize;
4
5use crate::compiler_interface::with;
6
7#[derive(#[automatically_derived]
impl ::core::clone::Clone for MachineInfo {
#[inline]
fn clone(&self) -> MachineInfo {
MachineInfo {
endian: ::core::clone::Clone::clone(&self.endian),
pointer_width: ::core::clone::Clone::clone(&self.pointer_width),
}
}
}Clone, #[automatically_derived]
impl ::core::cmp::PartialEq for MachineInfo {
#[inline]
fn eq(&self, other: &MachineInfo) -> bool {
self.endian == other.endian &&
self.pointer_width == other.pointer_width
}
}PartialEq, #[automatically_derived]
impl ::core::cmp::Eq for MachineInfo {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_receiver_is_total_eq(&self) {
let _: ::core::cmp::AssertParamIsEq<Endian>;
let _: ::core::cmp::AssertParamIsEq<MachineSize>;
}
}Eq, #[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications,
clippy :: absolute_paths,)]
const _: () =
{
#[allow(unused_extern_crates, clippy :: useless_attribute)]
extern crate serde as _serde;
;
#[automatically_derived]
impl _serde::Serialize for MachineInfo {
fn serialize<__S>(&self, __serializer: __S)
-> _serde::__private228::Result<__S::Ok, __S::Error> where
__S: _serde::Serializer {
let mut __serde_state =
_serde::Serializer::serialize_struct(__serializer,
"MachineInfo", false as usize + 1 + 1)?;
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"endian", &self.endian)?;
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"pointer_width", &self.pointer_width)?;
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};Serialize)]
9pub struct MachineInfo {
10 pub endian: Endian,
11 pub pointer_width: MachineSize,
12}
13
14impl MachineInfo {
15 pub fn target() -> MachineInfo {
16 with(|cx| cx.target_info())
17 }
18
19 pub fn target_endianness() -> Endian {
20 with(|cx| cx.target_info().endian)
21 }
22
23 pub fn target_pointer_width() -> MachineSize {
24 with(|cx| cx.target_info().pointer_width)
25 }
26}
27
28#[derive(#[automatically_derived]
impl ::core::marker::Copy for Endian { }Copy, #[automatically_derived]
impl ::core::clone::Clone for Endian {
#[inline]
fn clone(&self) -> Endian { *self }
}Clone, #[automatically_derived]
impl ::core::cmp::PartialEq for Endian {
#[inline]
fn eq(&self, other: &Endian) -> bool {
let __self_discr = ::core::intrinsics::discriminant_value(self);
let __arg1_discr = ::core::intrinsics::discriminant_value(other);
__self_discr == __arg1_discr
}
}PartialEq, #[automatically_derived]
impl ::core::cmp::Eq for Endian {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_receiver_is_total_eq(&self) {}
}Eq, #[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications,
clippy :: absolute_paths,)]
const _: () =
{
#[allow(unused_extern_crates, clippy :: useless_attribute)]
extern crate serde as _serde;
;
#[automatically_derived]
impl _serde::Serialize for Endian {
fn serialize<__S>(&self, __serializer: __S)
-> _serde::__private228::Result<__S::Ok, __S::Error> where
__S: _serde::Serializer {
match *self {
Endian::Little =>
_serde::Serializer::serialize_unit_variant(__serializer,
"Endian", 0u32, "Little"),
Endian::Big =>
_serde::Serializer::serialize_unit_variant(__serializer,
"Endian", 1u32, "Big"),
}
}
}
};Serialize)]
29pub enum Endian {
30 Little,
31 Big,
32}
33
34#[derive(#[automatically_derived]
impl ::core::marker::Copy for MachineSize { }Copy, #[automatically_derived]
impl ::core::clone::Clone for MachineSize {
#[inline]
fn clone(&self) -> MachineSize {
let _: ::core::clone::AssertParamIsClone<usize>;
*self
}
}Clone, #[automatically_derived]
impl ::core::cmp::PartialEq for MachineSize {
#[inline]
fn eq(&self, other: &MachineSize) -> bool {
self.num_bits == other.num_bits
}
}PartialEq, #[automatically_derived]
impl ::core::cmp::Eq for MachineSize {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_receiver_is_total_eq(&self) {
let _: ::core::cmp::AssertParamIsEq<usize>;
}
}Eq, #[automatically_derived]
impl ::core::cmp::PartialOrd for MachineSize {
#[inline]
fn partial_cmp(&self, other: &MachineSize)
-> ::core::option::Option<::core::cmp::Ordering> {
::core::cmp::PartialOrd::partial_cmp(&self.num_bits, &other.num_bits)
}
}PartialOrd, #[automatically_derived]
impl ::core::cmp::Ord for MachineSize {
#[inline]
fn cmp(&self, other: &MachineSize) -> ::core::cmp::Ordering {
::core::cmp::Ord::cmp(&self.num_bits, &other.num_bits)
}
}Ord, #[automatically_derived]
impl ::core::hash::Hash for MachineSize {
#[inline]
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
::core::hash::Hash::hash(&self.num_bits, state)
}
}Hash, #[automatically_derived]
impl ::core::fmt::Debug for MachineSize {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field1_finish(f, "MachineSize",
"num_bits", &&self.num_bits)
}
}Debug, #[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications,
clippy :: absolute_paths,)]
const _: () =
{
#[allow(unused_extern_crates, clippy :: useless_attribute)]
extern crate serde as _serde;
;
#[automatically_derived]
impl _serde::Serialize for MachineSize {
fn serialize<__S>(&self, __serializer: __S)
-> _serde::__private228::Result<__S::Ok, __S::Error> where
__S: _serde::Serializer {
let mut __serde_state =
_serde::Serializer::serialize_struct(__serializer,
"MachineSize", false as usize + 1)?;
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"num_bits", &self.num_bits)?;
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};Serialize)]
36pub struct MachineSize {
37 num_bits: usize,
38}
39
40impl MachineSize {
41 #[inline(always)]
42 pub fn bytes(self) -> usize {
43 self.num_bits / 8
44 }
45
46 #[inline(always)]
47 pub fn bits(self) -> usize {
48 self.num_bits
49 }
50
51 #[inline(always)]
52 pub fn from_bits(num_bits: usize) -> MachineSize {
53 MachineSize { num_bits }
54 }
55
56 #[inline]
57 pub fn unsigned_int_max(self) -> Option<u128> {
58 (self.num_bits <= 128).then(|| u128::MAX >> (128 - self.bits()))
59 }
60}