1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
#include "global.h" 
#include "string.h" 
 
#ifdef __i386__ 
ATTRIBUTE((fastcall)) 
#endif 
ATTRIBUTE((hot)) 
PMOD_EXPORT UINT64 low_hashmem_siphash24( const void *s, size_t len, size_t nbytes, 
                                                  UINT64 key ); 
 
#if PIKE_BYTEORDER == 1234 
ATTRIBUTE((unused)) 
static inline UINT64 low_hashmem_siphash24_uint32( const unsigned INT32 *in, size_t len, 
                                                           UINT64 key ) { 
    return low_hashmem_siphash24(in, len*4, len*4, key); 
} 
 
ATTRIBUTE((unused)) 
static inline UINT64 low_hashmem_siphash24_uint16( const unsigned INT16 *in, size_t len, 
                                                           UINT64 key ) { 
    return low_hashmem_siphash24(in, len*2, len*2, key); 
} 
 
#else 
ATTRIBUTE((unused)) 
#ifdef __i386__ 
ATTRIBUTE((fastcall)) 
#endif 
ATTRIBUTE((hot)) 
PMOD_EXPORT UINT64 low_hashmem_siphash24_uint32( const unsigned INT32 *in, size_t len, 
                                                         UINT64 key ); 
 
#ifdef __i386__ 
ATTRIBUTE((fastcall)) 
#endif 
ATTRIBUTE((hot)) 
PMOD_EXPORT UINT64 low_hashmem_siphash24_uint16( const unsigned INT16 *in, size_t len, 
                                                         UINT64 key ); 
#endif 
 
ATTRIBUTE((unused)) 
static inline UINT64 pike_string_siphash24(const struct pike_string *s, UINT64 key) { 
  if (s->size_shift == eightbit) { 
    return low_hashmem_siphash24(STR0(s), s->len, s->len, key); 
  } else if (s->size_shift == sixteenbit) { 
    return low_hashmem_siphash24_uint16(STR1(s), s->len, key); 
  } else { 
    return low_hashmem_siphash24_uint32((unsigned INT32*)STR2(s), s->len, key); 
  } 
}