From 9ae93d69628aa77efbc52477f85ecd1b7b1c58f1 Mon Sep 17 00:00:00 2001 From: Robert Habermeier Date: Tue, 7 Jun 2016 16:04:26 +0200 Subject: [PATCH 1/5] remove unsafety from util/hash.rs --- util/src/hash.rs | 106 +++++++++++++++++------------------------------ 1 file changed, 39 insertions(+), 67 deletions(-) diff --git a/util/src/hash.rs b/util/src/hash.rs index acb4c5cc5..20190f2de 100644 --- a/util/src/hash.rs +++ b/util/src/hash.rs @@ -150,10 +150,8 @@ macro_rules! impl_hash { } fn copy_to(&self, dest: &mut[u8]) { - unsafe { let min = ::std::cmp::min($size, dest.len()); - ::std::ptr::copy(self.0.as_ptr(), dest.as_mut_ptr(), min); - } + dest[..min].copy_from_slice(&self.0[..min]); } fn shift_bloomed<'a, T>(&'a mut self, b: &T) -> &'a mut Self where T: FixedHash { @@ -163,10 +161,7 @@ macro_rules! impl_hash { // impl |= instead // TODO: that's done now! - unsafe { - use std::{mem, ptr}; - ptr::copy(new_self.0.as_ptr(), self.0.as_mut_ptr(), mem::size_of::()); - } + self.0 = new_self.0; self } @@ -316,12 +311,9 @@ macro_rules! impl_hash { #[cfg_attr(feature="dev", allow(expl_impl_clone_on_copy))] impl Clone for $from { fn clone(&self) -> $from { - unsafe { - use std::{mem, ptr}; - let mut ret: $from = mem::uninitialized(); - ptr::copy(self.0.as_ptr(), ret.0.as_mut_ptr(), mem::size_of::<$from>()); - ret - } + let mut ret = $from::new(); + ret.0.copy_from_slice(&self.0); + ret } } @@ -404,14 +396,11 @@ macro_rules! impl_hash { type Output = $from; fn bitor(self, rhs: Self) -> Self::Output { - unsafe { - use std::mem; - let mut ret: $from = mem::uninitialized(); - for i in 0..$size { - ret.0[i] = self.0[i] | rhs.0[i]; - } - ret + let mut ret: $from = $from::default(); + for i in 0..$size { + ret.0[i] = self.0[i] | rhs.0[i]; } + ret } } @@ -429,14 +418,11 @@ macro_rules! impl_hash { type Output = $from; fn bitand(self, rhs: Self) -> Self::Output { - unsafe { - use std::mem; - let mut ret: $from = mem::uninitialized(); - for i in 0..$size { - ret.0[i] = self.0[i] & rhs.0[i]; - } - ret + let mut ret: $from = $from::default(); + for i in 0..$size { + ret.0[i] = self.0[i] & rhs.0[i]; } + ret } } @@ -454,14 +440,11 @@ macro_rules! impl_hash { type Output = $from; fn bitxor(self, rhs: Self) -> Self::Output { - unsafe { - use std::mem; - let mut ret: $from = mem::uninitialized(); - for i in 0..$size { - ret.0[i] = self.0[i] ^ rhs.0[i]; - } - ret + let mut ret: $from = $from::default(); + for i in 0..$size { + ret.0[i] = self.0[i] ^ rhs.0[i]; } + ret } } @@ -516,21 +499,17 @@ macro_rules! impl_hash { impl From for H256 { fn from(value: U256) -> H256 { - unsafe { - let mut ret: H256 = ::std::mem::uninitialized(); - value.to_raw_bytes(&mut ret); - ret - } + let mut ret = H256::new(); + value.to_raw_bytes(&mut ret); + ret } } impl<'a> From<&'a U256> for H256 { fn from(value: &'a U256) -> H256 { - unsafe { - let mut ret: H256 = ::std::mem::uninitialized(); - value.to_raw_bytes(&mut ret); - ret - } + let mut ret: H256 = H256::new(); + value.to_raw_bytes(&mut ret); + ret } } @@ -548,51 +527,44 @@ impl<'a> From<&'a H256> for U256 { impl From for Address { fn from(value: H256) -> Address { - unsafe { - let mut ret: Address = ::std::mem::uninitialized(); - ::std::ptr::copy(value.as_ptr().offset(12), ret.as_mut_ptr(), 20); - ret - } + let mut ret = Address::new(); + ret.0.copy_from_slice(&value[12..32]); + ret } } impl From for H64 { fn from(value: H256) -> H64 { - unsafe { - let mut ret: H64 = ::std::mem::uninitialized(); - ::std::ptr::copy(value.as_ptr().offset(20), ret.as_mut_ptr(), 8); - ret - } + let mut ret = H64::new(); + ret.0.copy_from_slice(&value[20..28]); + ret } } + /* impl<'a> From<&'a H256> for Address { fn from(value: &'a H256) -> Address { - unsafe { - let mut ret: Address = ::std::mem::uninitialized(); - ::std::ptr::copy(value.as_ptr().offset(12), ret.as_mut_ptr(), 20); + let mut ret = Address::new(); + ret.0.copy_from_slice(&value[12..32]); ret } } } */ + impl From
for H256 { fn from(value: Address) -> H256 { - unsafe { - let mut ret = H256::new(); - ::std::ptr::copy(value.as_ptr(), ret.as_mut_ptr().offset(12), 20); - ret - } + let mut ret = H256::new(); + ret.0[12..32].copy_from_slice(&value); + ret } } impl<'a> From<&'a Address> for H256 { fn from(value: &'a Address) -> H256 { - unsafe { - let mut ret = H256::new(); - ::std::ptr::copy(value.as_ptr(), ret.as_mut_ptr().offset(12), 20); - ret - } + let mut ret = H256::new(); + ret.0[12..32].copy_from_slice(&value); + ret } } From 482fe3b21112a6a398e4b57d5693ac9d5de49b5a Mon Sep 17 00:00:00 2001 From: Robert Habermeier Date: Tue, 7 Jun 2016 16:11:34 +0200 Subject: [PATCH 2/5] fixed indentation --- util/src/hash.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/util/src/hash.rs b/util/src/hash.rs index 20190f2de..290d5500a 100644 --- a/util/src/hash.rs +++ b/util/src/hash.rs @@ -150,8 +150,8 @@ macro_rules! impl_hash { } fn copy_to(&self, dest: &mut[u8]) { - let min = ::std::cmp::min($size, dest.len()); - dest[..min].copy_from_slice(&self.0[..min]); + let min = ::std::cmp::min($size, dest.len()); + dest[..min].copy_from_slice(&self.0[..min]); } fn shift_bloomed<'a, T>(&'a mut self, b: &T) -> &'a mut Self where T: FixedHash { From e46c9f67ab0731770b80f106cfbdfaa64c00a06b Mon Sep 17 00:00:00 2001 From: Robert Habermeier Date: Tue, 7 Jun 2016 16:15:17 +0200 Subject: [PATCH 3/5] remove outdated comments --- util/src/hash.rs | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/util/src/hash.rs b/util/src/hash.rs index 290d5500a..ab1255e39 100644 --- a/util/src/hash.rs +++ b/util/src/hash.rs @@ -143,6 +143,7 @@ macro_rules! impl_hash { } min } + fn from_slice(src: &[u8]) -> Self { let mut r = Self::new(); r.clone_from_slice(src); @@ -158,11 +159,7 @@ macro_rules! impl_hash { let bp: Self = b.bloom_part($size); let new_self = &bp | self; - // impl |= instead - // TODO: that's done now! - self.0 = new_self.0; - self } @@ -174,7 +171,6 @@ macro_rules! impl_hash { let bloom_bits = m * 8; let mask = bloom_bits - 1; let bloom_bytes = (log2(bloom_bits) + 7) / 8; - //println!("bb: {}", bloom_bytes); // must be a power of 2 assert_eq!(m & (m - 1), 0); From db869fcdd10792de5d618762345d45b94fc4a7f5 Mon Sep 17 00:00:00 2001 From: Robert Habermeier Date: Tue, 7 Jun 2016 16:18:50 +0200 Subject: [PATCH 4/5] remove unnecessary reference --- util/src/hash.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/util/src/hash.rs b/util/src/hash.rs index ab1255e39..6c1f8b2a4 100644 --- a/util/src/hash.rs +++ b/util/src/hash.rs @@ -559,7 +559,7 @@ impl From
for H256 { impl<'a> From<&'a Address> for H256 { fn from(value: &'a Address) -> H256 { let mut ret = H256::new(); - ret.0[12..32].copy_from_slice(&value); + ret.0[12..32].copy_from_slice(value); ret } } From 5168a1c8517f972667ece5cbea140a136c287d76 Mon Sep 17 00:00:00 2001 From: Robert Habermeier Date: Tue, 7 Jun 2016 16:42:07 +0200 Subject: [PATCH 5/5] remove some unsafety from uint.rs --- util/bigint/src/uint.rs | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/util/bigint/src/uint.rs b/util/bigint/src/uint.rs index f87b494a9..5c8da4a3c 100644 --- a/util/bigint/src/uint.rs +++ b/util/bigint/src/uint.rs @@ -92,8 +92,8 @@ macro_rules! uint_overflowing_add_reg { macro_rules! uint_overflowing_add { (U256, $n_words: expr, $self_expr: expr, $other: expr) => ({ let mut result: [u64; 4] = unsafe { mem::uninitialized() }; - let self_t: &[u64; 4] = unsafe { &mem::transmute($self_expr) }; - let other_t: &[u64; 4] = unsafe { &mem::transmute($other) }; + let self_t: &[u64; 4] = &self.0; + let other_t: &[u64; 4] = &other.0; let overflow: u8; unsafe { @@ -115,8 +115,8 @@ macro_rules! uint_overflowing_add { }); (U512, $n_words: expr, $self_expr: expr, $other: expr) => ({ let mut result: [u64; 8] = unsafe { mem::uninitialized() }; - let self_t: &[u64; 8] = unsafe { &mem::transmute($self_expr) }; - let other_t: &[u64; 8] = unsafe { &mem::transmute($other) }; + let self_t: &[u64; 8] = &self.0; + let other_t: &[u64; 8] = &other.0; let overflow: u8; @@ -196,8 +196,8 @@ macro_rules! uint_overflowing_sub_reg { macro_rules! uint_overflowing_sub { (U256, $n_words: expr, $self_expr: expr, $other: expr) => ({ let mut result: [u64; 4] = unsafe { mem::uninitialized() }; - let self_t: &[u64; 4] = unsafe { &mem::transmute($self_expr) }; - let other_t: &[u64; 4] = unsafe { &mem::transmute($other) }; + let self_t: &[u64; 4] = &self.0; + let other_t: &[u64; 4] = &other.0; let overflow: u8; unsafe { @@ -218,8 +218,8 @@ macro_rules! uint_overflowing_sub { }); (U512, $n_words: expr, $self_expr: expr, $other: expr) => ({ let mut result: [u64; 8] = unsafe { mem::uninitialized() }; - let self_t: &[u64; 8] = unsafe { &mem::transmute($self_expr) }; - let other_t: &[u64; 8] = unsafe { &mem::transmute($other) }; + let self_t: &[u64; 8] = &self.0; + let other_t: &[u64; 8] = &other.0; let overflow: u8; @@ -270,8 +270,8 @@ macro_rules! uint_overflowing_sub { macro_rules! uint_overflowing_mul { (U256, $n_words: expr, $self_expr: expr, $other: expr) => ({ let mut result: [u64; 4] = unsafe { mem::uninitialized() }; - let self_t: &[u64; 4] = unsafe { &mem::transmute($self_expr) }; - let other_t: &[u64; 4] = unsafe { &mem::transmute($other) }; + let self_t: &[u64; 4] = &self.0; + let other_t: &[u64; 4] = &self.0; let overflow: u64; unsafe { @@ -548,6 +548,7 @@ pub trait Uint: Sized + Default + FromStr + From + fmt::Debug + fmt::Displa macro_rules! construct_uint { ($name:ident, $n_words:expr) => ( /// Little-endian large integer type + #[repr(C)] #[derive(Copy, Clone, Eq, PartialEq)] pub struct $name(pub [u64; $n_words]); @@ -1132,8 +1133,8 @@ impl U256 { /// No overflow possible #[cfg(all(asm_available, target_arch="x86_64"))] pub fn full_mul(self, other: U256) -> U512 { - let self_t: &[u64; 4] = unsafe { &mem::transmute(self) }; - let other_t: &[u64; 4] = unsafe { &mem::transmute(other) }; + let self_t: &[u64; 4] = &self.0; + let other_t: &[u64; 4] = &other.0; let mut result: [u64; 8] = unsafe { mem::uninitialized() }; unsafe { asm!("