Line data    Source code

       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           0 : uint16_t static inline ReadLE16(const unsigned char* ptr)
      18             : {
      19             :     uint16_t x;
      20           0 :     memcpy(&x, ptr, 2);
      21           0 :     return le16toh(x);
      22             : }
      23             : 
      24     3023528 : uint32_t static inline ReadLE32(const unsigned char* ptr)
      25             : {
      26             :     uint32_t x;
      27     3023528 :     memcpy(&x, ptr, 4);
      28     3023528 :     return le32toh(x);
      29             : }
      30             : 
      31    11826831 : uint64_t static inline ReadLE64(const unsigned char* ptr)
      32             : {
      33             :     uint64_t x;
      34    11826831 :     memcpy(&x, ptr, 8);
      35    11826831 :     return le64toh(x);
      36             : }
      37             : 
      38           0 : void static inline WriteLE16(unsigned char* ptr, uint16_t x)
      39             : {
      40           0 :     uint16_t v = htole16(x);
      41           0 :     memcpy(ptr, &v, 2);
      42           0 : }
      43             : 
      44     2833496 : void static inline WriteLE32(unsigned char* ptr, uint32_t x)
      45             : {
      46     2833496 :     uint32_t v = htole32(x);
      47     2833496 :     memcpy(ptr, &v, 4);
      48     2833496 : }
      49             : 
      50           0 : void static inline WriteLE64(unsigned char* ptr, uint64_t x)
      51             : {
      52           0 :     uint64_t v = htole64(x);
      53           0 :     memcpy(ptr, &v, 8);
      54           0 : }
      55             : 
      56           0 : uint16_t static inline ReadBE16(const unsigned char* ptr)
      57             : {
      58             :     uint16_t x;
      59           0 :     memcpy(&x, ptr, 2);
      60           0 :     return be16toh(x);
      61             : }
      62             : 
      63        1872 : uint32_t static inline ReadBE32(const unsigned char* ptr)
      64             : {
      65             :     uint32_t x;
      66        1872 :     memcpy(&x, ptr, 4);
      67        1872 :     return be32toh(x);
      68             : }
      69             : 
      70     3875104 : uint64_t static inline ReadBE64(const unsigned char* ptr)
      71             : {
      72             :     uint64_t x;
      73     3875104 :     memcpy(&x, ptr, 8);
      74     3875104 :     return be64toh(x);
      75             : }
      76             : 
      77     1887648 : void static inline WriteBE32(unsigned char* ptr, uint32_t x)
      78             : {
      79     1887648 :     uint32_t v = htobe32(x);
      80     1887648 :     memcpy(ptr, &v, 4);
      81     1887648 : }
      82             : 
      83     2402832 : void static inline WriteBE64(unsigned char* ptr, uint64_t x)
      84             : {
      85     2402832 :     uint64_t v = htobe64(x);
      86     2402832 :     memcpy(ptr, &v, 8);
      87     2402832 : }
      88             : 
      89             : /** Return the smallest number n such that (x >> n) == 0 (or 64 if the highest bit in x is set. */
      90      183719 : uint64_t static inline CountBits(uint64_t x)
      91             : {
      92             : #if HAVE_BUILTIN_CLZL
      93             :     if (sizeof(unsigned long) >= sizeof(uint64_t)) {
      94      183719 :         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