1#![allow(deprecated)] use crate::marker::PhantomData;
6use crate::{cmp, mem, ptr};
7
8#[unstable(feature = "hashmap_internals", issue = "none")]
15#[deprecated(since = "1.13.0", note = "use `std::hash::DefaultHasher` instead")]
16#[derive(Debug, Clone, Default)]
17#[doc(hidden)]
18pub struct SipHasher13 {
19 hasher: Hasher<Sip13Rounds>,
20}
21
22#[unstable(feature = "hashmap_internals", issue = "none")]
26#[deprecated(since = "1.13.0", note = "use `std::hash::DefaultHasher` instead")]
27#[derive(Debug, Clone, Default)]
28struct SipHasher24 {
29 hasher: Hasher<Sip24Rounds>,
30}
31
32#[stable(feature = "rust1", since = "1.0.0")]
45#[deprecated(since = "1.13.0", note = "use `std::hash::DefaultHasher` instead")]
46#[derive(Debug, Clone, Default)]
47pub struct SipHasher(SipHasher24);
48
49#[derive(Debug)]
50struct Hasher<S: Sip> {
51 k0: u64,
52 k1: u64,
53 length: usize, state: State, tail: u64, ntail: usize, _marker: PhantomData<S>,
58}
59
60#[derive(Debug, Clone, Copy)]
61#[repr(C)]
62struct State {
63 v0: u64,
68 v2: u64,
69 v1: u64,
70 v3: u64,
71}
72
73macro_rules! compress {
74 ($state:expr) => {{ compress!($state.v0, $state.v1, $state.v2, $state.v3) }};
75 ($v0:expr, $v1:expr, $v2:expr, $v3:expr) => {{
76 $v0 = $v0.wrapping_add($v1);
77 $v2 = $v2.wrapping_add($v3);
78 $v1 = $v1.rotate_left(13);
79 $v1 ^= $v0;
80 $v3 = $v3.rotate_left(16);
81 $v3 ^= $v2;
82 $v0 = $v0.rotate_left(32);
83
84 $v2 = $v2.wrapping_add($v1);
85 $v0 = $v0.wrapping_add($v3);
86 $v1 = $v1.rotate_left(17);
87 $v1 ^= $v2;
88 $v3 = $v3.rotate_left(21);
89 $v3 ^= $v0;
90 $v2 = $v2.rotate_left(32);
91 }};
92}
93
94macro_rules! load_int_le {
101 ($buf:expr, $i:expr, $int_ty:ident) => {{
102 debug_assert!($i + mem::size_of::<$int_ty>() <= $buf.len());
103 let mut data = 0 as $int_ty;
104 ptr::copy_nonoverlapping(
105 $buf.as_ptr().add($i),
106 &mut data as *mut _ as *mut u8,
107 mem::size_of::<$int_ty>(),
108 );
109 data.to_le()
110 }};
111}
112
113#[inline]
120unsafe fn u8to64_le(buf: &[u8], start: usize, len: usize) -> u64 {
121 debug_assert!(len < 8);
122 let mut i = 0; let mut out = 0;
124 if i + 3 < len {
125 out = unsafe { load_int_le!(buf, start + i, u32) } as u64;
128 i += 4;
129 }
130 if i + 1 < len {
131 out |= (unsafe { load_int_le!(buf, start + i, u16) } as u64) << (i * 8);
133 i += 2
134 }
135 if i < len {
136 out |= (unsafe { *buf.get_unchecked(start + i) } as u64) << (i * 8);
138 i += 1;
139 }
140 debug_assert!(i == len);
142 out
143}
144
145impl SipHasher {
146 #[inline]
148 #[stable(feature = "rust1", since = "1.0.0")]
149 #[deprecated(since = "1.13.0", note = "use `std::hash::DefaultHasher` instead")]
150 #[must_use]
151 pub fn new() -> SipHasher {
152 SipHasher::new_with_keys(0, 0)
153 }
154
155 #[inline]
157 #[stable(feature = "rust1", since = "1.0.0")]
158 #[deprecated(since = "1.13.0", note = "use `std::hash::DefaultHasher` instead")]
159 #[must_use]
160 pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher {
161 SipHasher(SipHasher24 { hasher: Hasher::new_with_keys(key0, key1) })
162 }
163}
164
165impl SipHasher13 {
166 #[inline]
168 #[unstable(feature = "hashmap_internals", issue = "none")]
169 #[deprecated(since = "1.13.0", note = "use `std::hash::DefaultHasher` instead")]
170 pub fn new() -> SipHasher13 {
171 SipHasher13::new_with_keys(0, 0)
172 }
173
174 #[inline]
176 #[unstable(feature = "hashmap_internals", issue = "none")]
177 #[deprecated(since = "1.13.0", note = "use `std::hash::DefaultHasher` instead")]
178 pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher13 {
179 SipHasher13 { hasher: Hasher::new_with_keys(key0, key1) }
180 }
181}
182
183impl<S: Sip> Hasher<S> {
184 #[inline]
185 const fn new_with_keys(key0: u64, key1: u64) -> Hasher<S> {
186 let mut state = Hasher {
187 k0: key0,
188 k1: key1,
189 length: 0,
190 state: State { v0: 0, v1: 0, v2: 0, v3: 0 },
191 tail: 0,
192 ntail: 0,
193 _marker: PhantomData,
194 };
195 state.reset();
196 state
197 }
198
199 #[inline]
200 const fn reset(&mut self) {
201 self.length = 0;
202 self.state.v0 = self.k0 ^ 0x736f6d6570736575;
203 self.state.v1 = self.k1 ^ 0x646f72616e646f6d;
204 self.state.v2 = self.k0 ^ 0x6c7967656e657261;
205 self.state.v3 = self.k1 ^ 0x7465646279746573;
206 self.ntail = 0;
207 }
208}
209
210#[stable(feature = "rust1", since = "1.0.0")]
211impl super::Hasher for SipHasher {
212 #[inline]
213 fn write(&mut self, msg: &[u8]) {
214 self.0.hasher.write(msg)
215 }
216
217 #[inline]
218 fn write_str(&mut self, s: &str) {
219 self.0.hasher.write_str(s);
220 }
221
222 #[inline]
223 fn finish(&self) -> u64 {
224 self.0.hasher.finish()
225 }
226}
227
228#[unstable(feature = "hashmap_internals", issue = "none")]
229impl super::Hasher for SipHasher13 {
230 #[inline]
231 fn write(&mut self, msg: &[u8]) {
232 self.hasher.write(msg)
233 }
234
235 #[inline]
236 fn write_str(&mut self, s: &str) {
237 self.hasher.write_str(s);
238 }
239
240 #[inline]
241 fn finish(&self) -> u64 {
242 self.hasher.finish()
243 }
244}
245
246impl<S: Sip> super::Hasher for Hasher<S> {
247 #[inline]
255 fn write(&mut self, msg: &[u8]) {
256 let length = msg.len();
257 self.length += length;
258
259 let mut needed = 0;
260
261 if self.ntail != 0 {
262 needed = 8 - self.ntail;
263 self.tail |= unsafe { u8to64_le(msg, 0, cmp::min(length, needed)) } << (8 * self.ntail);
265 if length < needed {
266 self.ntail += length;
267 return;
268 } else {
269 self.state.v3 ^= self.tail;
270 S::c_rounds(&mut self.state);
271 self.state.v0 ^= self.tail;
272 self.ntail = 0;
273 }
274 }
275
276 let len = length - needed;
278 let left = len & 0x7; let mut i = needed;
281 while i < len - left {
282 let mi = unsafe { load_int_le!(msg, i, u64) };
286
287 self.state.v3 ^= mi;
288 S::c_rounds(&mut self.state);
289 self.state.v0 ^= mi;
290
291 i += 8;
292 }
293
294 self.tail = unsafe { u8to64_le(msg, i, left) };
298 self.ntail = left;
299 }
300
301 #[inline]
302 fn write_str(&mut self, s: &str) {
303 self.write(s.as_bytes());
306 self.write_u8(0xFF);
307 }
308
309 #[inline]
310 fn finish(&self) -> u64 {
311 let mut state = self.state;
312
313 let b: u64 = ((self.length as u64 & 0xff) << 56) | self.tail;
314
315 state.v3 ^= b;
316 S::c_rounds(&mut state);
317 state.v0 ^= b;
318
319 state.v2 ^= 0xff;
320 S::d_rounds(&mut state);
321
322 state.v0 ^ state.v1 ^ state.v2 ^ state.v3
323 }
324}
325
326impl<S: Sip> Clone for Hasher<S> {
327 #[inline]
328 fn clone(&self) -> Hasher<S> {
329 Hasher {
330 k0: self.k0,
331 k1: self.k1,
332 length: self.length,
333 state: self.state,
334 tail: self.tail,
335 ntail: self.ntail,
336 _marker: self._marker,
337 }
338 }
339}
340
341impl<S: Sip> Default for Hasher<S> {
342 #[inline]
344 fn default() -> Hasher<S> {
345 Hasher::new_with_keys(0, 0)
346 }
347}
348
349#[doc(hidden)]
350trait Sip {
351 fn c_rounds(_: &mut State);
352 fn d_rounds(_: &mut State);
353}
354
355#[derive(Debug, Clone, Default)]
356struct Sip13Rounds;
357
358impl Sip for Sip13Rounds {
359 #[inline]
360 fn c_rounds(state: &mut State) {
361 compress!(state);
362 }
363
364 #[inline]
365 fn d_rounds(state: &mut State) {
366 compress!(state);
367 compress!(state);
368 compress!(state);
369 }
370}
371
372#[derive(Debug, Clone, Default)]
373struct Sip24Rounds;
374
375impl Sip for Sip24Rounds {
376 #[inline]
377 fn c_rounds(state: &mut State) {
378 compress!(state);
379 compress!(state);
380 }
381
382 #[inline]
383 fn d_rounds(state: &mut State) {
384 compress!(state);
385 compress!(state);
386 compress!(state);
387 compress!(state);
388 }
389}