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    81691430 : uint32_t static inline ReadLE32(const unsigned char* ptr)
      25             : {
      26    81691430 :     uint32_t x;
      27    79213102 :     memcpy((char*)&x, ptr, 4);
      28    79213102 :     return le32toh(x);
      29             : }
      30             : 
      31    92558890 : uint64_t static inline ReadLE64(const unsigned char* ptr)
      32             : {
      33    92558890 :     uint64_t x;
      34    14154900 :     memcpy((char*)&x, ptr, 8);
      35    14154900 :     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   210697325 : void static inline WriteLE32(unsigned char* ptr, uint32_t x)
      45             : {
      46   210697325 :     uint32_t v = htole32(x);
      47   210697325 :     memcpy(ptr, (char*)&v, 4);
      48             : }
      49             : 
      50    12419635 : void static inline WriteLE64(unsigned char* ptr, uint64_t x)
      51             : {
      52    12419635 :     uint64_t v = htole64(x);
      53    12419635 :     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  1378368197 : uint32_t static inline ReadBE32(const unsigned char* ptr)
      64             : {
      65  1470123197 :     uint32_t x;
      66    93955497 :     memcpy((char*)&x, ptr, 4);
      67    93955497 :     return be32toh(x);
      68             : }
      69             : 
      70  3533781000 : uint64_t static inline ReadBE64(const unsigned char* ptr)
      71             : {
      72  3533781000 :     uint64_t x;
      73   220861200 :     memcpy((char*)&x, ptr, 8);
      74   220861200 :     return be64toh(x);
      75             : }
      76             : 
      77    27085499 : void static inline WriteBE32(unsigned char* ptr, uint32_t x)
      78             : {
      79    27085499 :     uint32_t v = htobe32(x);
      80    27085499 :     memcpy(ptr, (char*)&v, 4);
      81             : }
      82             : 
      83   467137599 : void static inline WriteBE64(unsigned char* ptr, uint64_t x)
      84             : {
      85   247121199 :     uint64_t v = htobe64(x);
      86   247121199 :     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     4708200 : uint64_t static inline CountBits(uint64_t x)
      91             : {
      92             : #if HAVE_DECL___BUILTIN_CLZL
      93     4708200 :     if (sizeof(unsigned long) >= sizeof(uint64_t)) {
      94     4708200 :         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