From 74572ba409540b7a311767ef50c759627e0d7b0d Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Fri, 23 Dec 2022 20:23:16 +0000 Subject: [PATCH] Support u128 values --- c-bindings-gen/src/types.rs | 11 ++++++-- lightning-c-bindings/src/c_types/mod.rs | 35 ++++++++++++++++++++++--- 2 files changed, 41 insertions(+), 5 deletions(-) diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs index 5ced910..a678e7a 100644 --- a/c-bindings-gen/src/types.rs +++ b/c-bindings-gen/src/types.rs @@ -539,6 +539,7 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr let mut imports = HashMap::new(); // Add primitives to the "imports" list: Self::insert_primitive(&mut imports, "bool"); + Self::insert_primitive(&mut imports, "u128"); Self::insert_primitive(&mut imports, "u64"); Self::insert_primitive(&mut imports, "u32"); Self::insert_primitive(&mut imports, "u16"); @@ -797,7 +798,8 @@ impl FullLibraryAST { /// List of manually-generated types which are clonable fn initial_clonable_types() -> HashSet { let mut res = HashSet::new(); - res.insert("crate::c_types::u5".to_owned()); + res.insert("crate::c_types::U5".to_owned()); + res.insert("crate::c_types::U128".to_owned()); res.insert("crate::c_types::FourBytes".to_owned()); res.insert("crate::c_types::TwelveBytes".to_owned()); res.insert("crate::c_types::SixteenBytes".to_owned()); @@ -987,7 +989,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { "core::num::ParseIntError" => Some("crate::c_types::Error"), "core::str::Utf8Error" => Some("crate::c_types::Error"), - "bitcoin::bech32::u5"|"bech32::u5" => Some("crate::c_types::u5"), + "bitcoin::bech32::u5"|"bech32::u5" => Some("crate::c_types::U5"), + "u128" => Some("crate::c_types::U128"), "core::num::NonZeroU8" => Some("u8"), "secp256k1::PublicKey"|"bitcoin::secp256k1::PublicKey" => Some("crate::c_types::PublicKey"), @@ -1075,6 +1078,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { "std::time::SystemTime" => Some("(::std::time::SystemTime::UNIX_EPOCH + std::time::Duration::from_secs("), "bitcoin::bech32::u5"|"bech32::u5" => Some(""), + "u128" => Some(""), "core::num::NonZeroU8" => Some("core::num::NonZeroU8::new("), "bitcoin::secp256k1::PublicKey"|"secp256k1::PublicKey" if is_ref => Some("&"), @@ -1164,6 +1168,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { "std::time::SystemTime" => Some("))"), "bitcoin::bech32::u5"|"bech32::u5" => Some(".into()"), + "u128" => Some(".into()"), "core::num::NonZeroU8" => Some(").expect(\"Value must be non-zero\")"), "bitcoin::secp256k1::PublicKey"|"secp256k1::PublicKey" => Some(".into_rust()"), @@ -1261,6 +1266,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { "core::str::Utf8Error" => Some("crate::c_types::Error { _dummy: 0 } /*"), "bitcoin::bech32::u5"|"bech32::u5" => Some(""), + "u128" => Some(""), "bitcoin::secp256k1::PublicKey"|"secp256k1::PublicKey" => Some("crate::c_types::PublicKey::from_rust(&"), "bitcoin::secp256k1::ecdsa::Signature" => Some("crate::c_types::Signature::from_rust(&"), @@ -1341,6 +1347,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { "core::str::Utf8Error" => Some("*/"), "bitcoin::bech32::u5"|"bech32::u5" => Some(".into()"), + "u128" => Some(".into()"), "bitcoin::secp256k1::PublicKey"|"secp256k1::PublicKey" => Some(")"), "bitcoin::secp256k1::ecdsa::Signature" => Some(")"), diff --git a/lightning-c-bindings/src/c_types/mod.rs b/lightning-c-bindings/src/c_types/mod.rs index 7161637..6720039 100644 --- a/lightning-c-bindings/src/c_types/mod.rs +++ b/lightning-c-bindings/src/c_types/mod.rs @@ -41,15 +41,44 @@ impl From for NotConstructable { #[derive(PartialEq, Eq, Copy, Clone)] #[allow(non_camel_case_types)] #[repr(C)] -pub struct u5(u8); +pub struct U5(u8); -impl From for u5 { +impl From for U5 { fn from(o: bech32::u5) -> Self { Self(o.to_u8()) } } -impl Into for u5 { +impl Into for U5 { fn into(self) -> bech32::u5 { bech32::u5::try_from_u8(self.0).expect("u5 objects must be in the range 0..32") } } +/// Unsigned, 128-bit integer. +/// +/// Because LLVM implements an incorrect ABI for 128-bit integers, a wrapper type is defined here. +/// See https://github.com/rust-lang/rust/issues/54341 for more details. +#[derive(PartialEq, Eq, Copy, Clone)] +#[allow(non_camel_case_types)] +#[repr(C)] +pub struct U128 { + /// The 128-bit integer, as 16 little-endian bytes + pub le_bytes: [u8; 16], +} + +#[no_mangle] +/// Gets the 128-bit integer, as 16 little-endian bytes +pub extern "C" fn U128_le_bytes(val: U128) -> SixteenBytes { SixteenBytes { data: val.le_bytes } } +#[no_mangle] +/// Constructs a new U128 from 16 little-endian bytes +pub extern "C" fn U128_new(le_bytes: SixteenBytes) -> U128 { U128 { le_bytes: le_bytes.data } } + +impl From for U128 { + fn from(o: u128) -> Self { Self { le_bytes: o.to_le_bytes() } } +} +impl From<&mut u128> for U128 { + fn from(o: &mut u128) -> U128 { Self::from(*o) } +} +impl Into for U128 { + fn into(self) -> u128 { u128::from_le_bytes(self.le_bytes) } +} + /// Integer in the range `0..=16` #[derive(PartialEq, Eq, Copy, Clone)] #[repr(C)] -- 2.39.5