Bitcoin Core Fuzz Coverage Report

// Copyright (c) 2014-present The Bitcoin Core developers

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#ifndef BITCOIN_CRYPTO_COMMON_H

#define BITCOIN_CRYPTO_COMMON_H

#include <compat/endian.h>

#include <concepts>

#include <cstddef>

#include <cstdint>

#include <cstring>

template <typename B>

concept ByteType = std::same_as<B, unsigned char> || std::same_as<B, std::byte>;

template <ByteType B>

inline uint16_t ReadLE16(const B* ptr)

{

    uint16_t x;

    memcpy(&x, ptr, 2);

    return le16toh_internal(x);

}

template <ByteType B>

inline uint32_t ReadLE32(const B* ptr)

{

    uint32_t x;

    memcpy(&x, ptr, 4);

    return le32toh_internal(x);

}

unsigned int ReadLE32<unsigned char>(unsigned char const*)

Line

Count

Source

28

17.0k

{

29

17.0k

    uint32_t x;

30

17.0k

    memcpy(&x, ptr, 4);

31

17.0k

    return le32toh_internal(x);

32

17.0k

}

unsigned int ReadLE32<std::byte>(std::byte const*)

Line

Count

Source

28

329k

{

29

329k

    uint32_t x;

30

329k

    memcpy(&x, ptr, 4);

31

329k

    return le32toh_internal(x);

32

329k

}

template <ByteType B>

inline uint64_t ReadLE64(const B* ptr)

{

    uint64_t x;

    memcpy(&x, ptr, 8);

    return le64toh_internal(x);

}

unsigned long long ReadLE64<unsigned char>(unsigned char const*)

Line

Count

Source

36

6.04k

{

37

6.04k

    uint64_t x;

38

6.04k

    memcpy(&x, ptr, 8);

39

6.04k

    return le64toh_internal(x);

40

6.04k

}

unsigned long long ReadLE64<std::byte>(std::byte const*)

Line

Count

Source

36

27.9k

{

37

27.9k

    uint64_t x;

38

27.9k

    memcpy(&x, ptr, 8);

39

27.9k

    return le64toh_internal(x);

40

27.9k

}

template <ByteType B>

inline void WriteLE16(B* ptr, uint16_t x)

{

    uint16_t v = htole16_internal(x);

    memcpy(ptr, &v, 2);

}

template <ByteType B>

inline void WriteLE32(B* ptr, uint32_t x)

{

    uint32_t v = htole32_internal(x);

    memcpy(ptr, &v, 4);

}

Unexecuted instantiation: void WriteLE32<unsigned char>(unsigned char*, unsigned int)

void WriteLE32<std::byte>(std::byte*, unsigned int)

Line

Count

Source

51

428k

{

52

428k

    uint32_t v = htole32_internal(x);

53

428k

    memcpy(ptr, &v, 4);

54

428k

}

template <ByteType B>

inline void WriteLE64(B* ptr, uint64_t x)

{

    uint64_t v = htole64_internal(x);

    memcpy(ptr, &v, 8);

}

Unexecuted instantiation: void WriteLE64<std::byte>(std::byte*, unsigned long long)

void WriteLE64<unsigned char>(unsigned char*, unsigned long long)

Line

Count

Source

58

292

{

59

292

    uint64_t v = htole64_internal(x);

60

292

    memcpy(ptr, &v, 8);

61

292

}

template <ByteType B>

inline uint16_t ReadBE16(const B* ptr)

{

    uint16_t x;

    memcpy(&x, ptr, 2);

    return be16toh_internal(x);

}

template <ByteType B>

inline uint32_t ReadBE32(const B* ptr)

{

    uint32_t x;

    memcpy(&x, ptr, 4);

    return be32toh_internal(x);

}

unsigned int ReadBE32<unsigned char>(unsigned char const*)

Line

Count

Source

73

1.00k

{

74

1.00k

    uint32_t x;

75

1.00k

    memcpy(&x, ptr, 4);

76

1.00k

    return be32toh_internal(x);

77

1.00k

}

Unexecuted instantiation: unsigned int ReadBE32<std::byte>(std::byte const*)

template <ByteType B>

inline uint64_t ReadBE64(const B* ptr)

{

    uint64_t x;

    memcpy(&x, ptr, 8);

    return be64toh_internal(x);

}

template <ByteType B>

inline void WriteBE16(B* ptr, uint16_t x)

{

    uint16_t v = htobe16_internal(x);

    memcpy(ptr, &v, 2);

}

template <ByteType B>

inline void WriteBE32(B* ptr, uint32_t x)

{

    uint32_t v = htobe32_internal(x);

    memcpy(ptr, &v, 4);

}

template <ByteType B>

inline void WriteBE64(B* ptr, uint64_t x)

{

    uint64_t v = htobe64_internal(x);

    memcpy(ptr, &v, 8);

}

#endif // BITCOIN_CRYPTO_COMMON_H