1
// Copyright (c) 2014-2020 The Bitcoin Core developers
2
// Distributed under the MIT software license, see the accompanying
3
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4

            
5
#ifndef BITCOIN_CRYPTO_COMMON_H
6
#define BITCOIN_CRYPTO_COMMON_H
7

            
8
#if defined(HAVE_CONFIG_H)
9
#include <config/bitcoin-config.h>
10
#endif
11

            
12
#include <stdint.h>
13
#include <string.h>
14

            
15
#include <compat/endian.h>
16

            
17
uint16_t static inline ReadLE16(const unsigned char* ptr)
18
{
19
    uint16_t x;
20
    memcpy((char*)&x, ptr, 2);
21
    return le16toh(x);
22
}
23

            
24
uint32_t static inline ReadLE32(const unsigned char* ptr)
25
141216
{
26
141216
    uint32_t x;
27
141216
    memcpy((char*)&x, ptr, 4);
28
141216
    return le32toh(x);
29
141216
}
30

            
31
uint64_t static inline ReadLE64(const unsigned char* ptr)
32
{
33
    uint64_t x;
34
    memcpy((char*)&x, ptr, 8);
35
    return le64toh(x);
36
}
37

            
38
void static inline WriteLE16(unsigned char* ptr, uint16_t x)
39
{
40
    uint16_t v = htole16(x);
41
    memcpy(ptr, (char*)&v, 2);
42
}
43

            
44
void static inline WriteLE32(unsigned char* ptr, uint32_t x)
45
44642
{
46
44642
    uint32_t v = htole32(x);
47
44642
    memcpy(ptr, (char*)&v, 4);
48
44642
}
49

            
50
void static inline WriteLE64(unsigned char* ptr, uint64_t x)
51
8826
{
52
8826
    uint64_t v = htole64(x);
53
8826
    memcpy(ptr, (char*)&v, 8);
54
8826
}
55

            
56
uint16_t static inline ReadBE16(const unsigned char* ptr)
57
{
58
    uint16_t x;
59
    memcpy((char*)&x, ptr, 2);
60
    return be16toh(x);
61
}
62

            
63
uint32_t static inline ReadBE32(const unsigned char* ptr)
64
682240
{
65
682240
    uint32_t x;
66
682240
    memcpy((char*)&x, ptr, 4);
67
682240
    return be32toh(x);
68
682240
}
69

            
70
uint64_t static inline ReadBE64(const unsigned char* ptr)
71
389840
{
72
389840
    uint64_t x;
73
389840
    memcpy((char*)&x, ptr, 8);
74
389840
    return be64toh(x);
75
389840
}
76

            
77
void static inline WriteBE32(unsigned char* ptr, uint32_t x)
78
113120
{
79
113120
    uint32_t v = htobe32(x);
80
113120
    memcpy(ptr, (char*)&v, 4);
81
113120
}
82

            
83
void static inline WriteBE64(unsigned char* ptr, uint64_t x)
84
230185
{
85
230185
    uint64_t v = htobe64(x);
86
230185
    memcpy(ptr, (char*)&v, 8);
87
230185
}
88

            
89
/** Return the smallest number n such that (x >> n) == 0 (or 64 if the highest bit in x is set. */
90
uint64_t static inline CountBits(uint64_t x)
91
{
92
#if HAVE_BUILTIN_CLZL
93
    if (sizeof(unsigned long) >= sizeof(uint64_t)) {
94
        return x ? 8 * sizeof(unsigned long) - __builtin_clzl(x) : 0;
95
    }
96
#endif
97
#if HAVE_BUILTIN_CLZLL
98
    if (sizeof(unsigned long long) >= sizeof(uint64_t)) {
99
        return x ? 8 * sizeof(unsigned long long) - __builtin_clzll(x) : 0;
100
    }
101
#endif
102
    int ret = 0;
103
    while (x) {
104
        x >>= 1;
105
        ++ret;
106
    }
107
    return ret;
108
}
109

            
110
#endif // BITCOIN_CRYPTO_COMMON_H