Line data    Source code

       1             : // Copyright (c) 2014-2018 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 PIVX_CRYPTO_COMMON_H
       6             : #define PIVX_CRYPTO_COMMON_H
       7             : 
       8             : #if defined(HAVE_CONFIG_H)
       9             : #include <config/pivx-config.h>
      10             : #endif
      11             : 
      12             : #include <stdint.h>
      13             : #include <string.h>
      14             : 
      15             : #include <compat/endian.h>
      16             : 
      17        6254 : uint16_t static inline ReadLE16(const unsigned char* ptr)
      18             : {
      19        6254 :     uint16_t x;
      20        6254 :     memcpy((char*)&x, ptr, 2);
      21        6254 :     return le16toh(x);
      22             : }
      23             : 
      24    84131568 : uint32_t static inline ReadLE32(const unsigned char* ptr)
      25             : {
      26    84131568 :     uint32_t x;
      27    81509526 :     memcpy((char*)&x, ptr, 4);
      28    81509526 :     return le32toh(x);
      29             : }
      30             : 
      31    93775224 : uint64_t static inline ReadLE64(const unsigned char* ptr)
      32             : {
      33    93775224 :     uint64_t x;
      34    15866195 :     memcpy((char*)&x, ptr, 8);
      35    15866195 :     return le64toh(x);
      36             : }
      37             : 
      38         344 : void static inline WriteLE16(unsigned char* ptr, uint16_t x)
      39             : {
      40         344 :     uint16_t v = htole16(x);
      41         344 :     memcpy(ptr, (char*)&v, 2);
      42             : }
      43             : 
      44   213404120 : void static inline WriteLE32(unsigned char* ptr, uint32_t x)
      45             : {
      46   213404120 :     uint32_t v = htole32(x);
      47   213404120 :     memcpy(ptr, (char*)&v, 4);
      48             : }
      49             : 
      50    13805852 : void static inline WriteLE64(unsigned char* ptr, uint64_t x)
      51             : {
      52    13805852 :     uint64_t v = htole64(x);
      53    13805852 :     memcpy(ptr, (char*)&v, 8);
      54             : }
      55             : 
      56           1 : uint16_t static inline ReadBE16(const unsigned char* ptr)
      57             : {
      58           1 :     uint16_t x;
      59           1 :     memcpy((char*)&x, ptr, 2);
      60           1 :     return be16toh(x);
      61             : }
      62             : 
      63  1507957518 : uint32_t static inline ReadBE32(const unsigned char* ptr)
      64             : {
      65  1608324518 :     uint32_t x;
      66   102601418 :     memcpy((char*)&x, ptr, 4);
      67   102601418 :     return be32toh(x);
      68             : }
      69             : 
      70  3548440000 : uint64_t static inline ReadBE64(const unsigned char* ptr)
      71             : {
      72  3548440000 :     uint64_t x;
      73   221777600 :     memcpy((char*)&x, ptr, 8);
      74   221777600 :     return be64toh(x);
      75             : }
      76             : 
      77    31815445 : void static inline WriteBE32(unsigned char* ptr, uint32_t x)
      78             : {
      79    31815445 :     uint32_t v = htobe32(x);
      80    31815445 :     memcpy(ptr, (char*)&v, 4);
      81             : }
      82             : 
      83   473738805 : void static inline WriteBE64(unsigned char* ptr, uint64_t x)
      84             : {
      85   252805505 :     uint64_t v = htobe64(x);
      86   252805505 :     memcpy(ptr, (char*)&v, 8);
      87             : }
      88             : 
      89             : /** Return the smallest number n such that (x >> n) == 0 (or 64 if the highest bit in x is set. */
      90     4832396 : uint64_t static inline CountBits(uint64_t x)
      91             : {
      92             : #if HAVE_DECL___BUILTIN_CLZL
      93     4832396 :     if (sizeof(unsigned long) >= sizeof(uint64_t)) {
      94     4832396 :         return x ? 8 * sizeof(unsigned long) - __builtin_clzl(x) : 0;
      95             :     }
      96             : #endif
      97             : #if HAVE_DECL___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 // PIVX_CRYPTO_COMMON_H