Branch data     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                 :             : #include <compat/endian.h>
       9                 :             : 
      10                 :             : #include <cstdint>
      11                 :             : #include <cstring>
      12                 :             : 
      13                 :      242981 : uint16_t static inline ReadLE16(const unsigned char* ptr)
      14                 :             : {
      15                 :      242981 :     uint16_t x;
      16         [ -  + ]:      242981 :     memcpy(&x, ptr, 2);
      17         [ -  + ]:      242981 :     return le16toh_internal(x);
      18                 :             : }
      19                 :             : 
      20                 :   204439094 : uint32_t static inline ReadLE32(const unsigned char* ptr)
      21                 :             : {
      22                 :   204439094 :     uint32_t x;
      23         [ +  + ]:   175683385 :     memcpy(&x, ptr, 4);
      24         [ +  + ]:   175683385 :     return le32toh_internal(x);
      25                 :             : }
      26                 :             : 
      27                 :   336051988 : uint64_t static inline ReadLE64(const unsigned char* ptr)
      28                 :             : {
      29                 :   336051988 :     uint64_t x;
      30         [ -  + ]:   336051988 :     memcpy(&x, ptr, 8);
           [ +  +  +  + ]
      31         [ -  + ]:   336051988 :     return le64toh_internal(x);
           [ +  +  +  + ]
      32                 :             : }
      33                 :             : 
      34                 :        8082 : void static inline WriteLE16(unsigned char* ptr, uint16_t x)
      35                 :             : {
      36                 :        8082 :     uint16_t v = htole16_internal(x);
      37                 :        8082 :     memcpy(ptr, &v, 2);
      38                 :        8082 : }
      39                 :             : 
      40                 :   817809183 : void static inline WriteLE32(unsigned char* ptr, uint32_t x)
      41                 :             : {
      42                 :   817809183 :     uint32_t v = htole32_internal(x);
      43                 :   817809183 :     memcpy(ptr, &v, 4);
      44                 :   817809183 : }
      45                 :             : 
      46                 :   482889533 : void static inline WriteLE64(unsigned char* ptr, uint64_t x)
      47                 :             : {
      48                 :   482889533 :     uint64_t v = htole64_internal(x);
      49                 :   482889533 :     memcpy(ptr, &v, 8);
      50                 :   482889533 : }
      51                 :             : 
      52                 :      594186 : uint16_t static inline ReadBE16(const unsigned char* ptr)
      53                 :             : {
      54                 :      594186 :     uint16_t x;
      55 [ -  + ][ #  #  :      594186 :     memcpy(&x, ptr, 2);
          #  #  #  #  #  
                      # ]
      56 [ -  + ][ #  #  :      594186 :     return be16toh_internal(x);
          #  #  #  #  #  
             #  #  #  #  
                      # ]
      57                 :             : }
      58                 :             : 
      59                 :   769329535 : uint32_t static inline ReadBE32(const unsigned char* ptr)
      60                 :             : {
      61                 :   769329535 :     uint32_t x;
      62         [ +  + ]:   119183155 :     memcpy(&x, ptr, 4);
           [ #  #  #  # ]
           [ +  -  +  -  
             +  -  +  - ]
      63         [ +  + ]:   119183155 :     return be32toh_internal(x);
           [ #  #  #  # ]
           [ +  -  +  -  
             +  -  +  - ]
      64                 :             : }
      65                 :             : 
      66                 :   504586835 : uint64_t static inline ReadBE64(const unsigned char* ptr)
      67                 :             : {
      68                 :   538225954 :     uint64_t x;
      69         [ -  + ]:    33639169 :     memcpy(&x, ptr, 8);
      70         [ -  + ]:    33639169 :     return be64toh_internal(x);
      71                 :             : }
      72                 :             : 
      73                 :          25 : void static inline WriteBE16(unsigned char* ptr, uint16_t x)
      74                 :             : {
      75                 :          25 :     uint16_t v = htobe16_internal(x);
      76                 :          25 :     memcpy(ptr, &v, 2);
      77                 :          25 : }
      78                 :             : 
      79                 :  1861898849 : void static inline WriteBE32(unsigned char* ptr, uint32_t x)
      80                 :             : {
      81                 :  1861898849 :     uint32_t v = htobe32_internal(x);
      82                 :  1861898849 :     memcpy(ptr, &v, 4);
      83                 :  1861898849 : }
      84                 :             : 
      85                 :   500622317 : void static inline WriteBE64(unsigned char* ptr, uint64_t x)
      86                 :             : {
      87                 :   500622317 :     uint64_t v = htobe64_internal(x);
      88                 :   500622317 :     memcpy(ptr, &v, 8);
      89                 :   500622317 : }
      90                 :             : 
      91                 :             : #endif // BITCOIN_CRYPTO_COMMON_H