// Copyright (c) 2019, Paul Dreik

// For the license information refer to format.h.

#ifndef FUZZER_COMMON_H

#define FUZZER_COMMON_H

#include <fmt/base.h>

#include <cstdint>  // std::uint8_t

#include <cstring>  // memcpy

#include <vector>

// One can format to either a string, or a buffer. The latter is faster, but

// one may be interested in formatting to a string instead to verify it works

// as intended. To avoid a combinatoric explosion, select this at compile time

// instead of dynamically from the fuzz data.

#define FMT_FUZZ_FORMAT_TO_STRING 0

// If {fmt} is given a buffer that is separately allocated, chances that address

// sanitizer detects out of bound reads is much higher. However, it slows down

// the fuzzing.

#define FMT_FUZZ_SEPARATE_ALLOCATION 1

// The size of the largest possible type in use.

// To let the fuzzer mutation be efficient at cross pollinating between

// different types, use a fixed size format. The same bit pattern, interpreted

// as another type, is likely interesting.

constexpr auto fixed_size = 16;

// Casts data to a char pointer.

template <typename T> inline const char* as_chars(const T* data) {

  return reinterpret_cast<const char*>(data);

}

// Casts data to a byte pointer.

template <typename T> inline const std::uint8_t* as_bytes(const T* data) {

  return reinterpret_cast<const std::uint8_t*>(data);

}

// Blits bytes from data to form an (assumed trivially constructible) object

// of type Item.

template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {

  auto item = Item();

  std::memcpy(&item, data, sizeof(Item));

  return item;

}

char assign_from_buf<char>(unsigned char const*)

Line

Count

Source

42

3.08k

template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {

43

3.08k

  auto item = Item();

44

3.08k

  std::memcpy(&item, data, sizeof(Item));

45

3.08k

  return item;

46

3.08k

}

signed char assign_from_buf<signed char>(unsigned char const*)

Line

Count

Source

42

3.18k

template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {

43

3.18k

  auto item = Item();

44

3.18k

  std::memcpy(&item, data, sizeof(Item));

45

3.18k

  return item;

46

3.18k

}

unsigned char assign_from_buf<unsigned char>(unsigned char const*)

Line

Count

Source

42

3.03k

template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {

43

3.03k

  auto item = Item();

44

3.03k

  std::memcpy(&item, data, sizeof(Item));

45

3.03k

  return item;

46

3.03k

}

short assign_from_buf<short>(unsigned char const*)

Line

Count

Source

42

3.24k

template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {

43

3.24k

  auto item = Item();

44

3.24k

  std::memcpy(&item, data, sizeof(Item));

45

3.24k

  return item;

46

3.24k

}

unsigned short assign_from_buf<unsigned short>(unsigned char const*)

Line

Count

Source

42

3.01k

template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {

43

3.01k

  auto item = Item();

44

3.01k

  std::memcpy(&item, data, sizeof(Item));

45

3.01k

  return item;

46

3.01k

}

int assign_from_buf<int>(unsigned char const*)

Line

Count

Source

42

3.43k

template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {

43

3.43k

  auto item = Item();

44

3.43k

  std::memcpy(&item, data, sizeof(Item));

45

3.43k

  return item;

46

3.43k

}

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

Line

Count

Source

42

3.13k

template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {

43

3.13k

  auto item = Item();

44

3.13k

  std::memcpy(&item, data, sizeof(Item));

45

3.13k

  return item;

46

3.13k

}

long assign_from_buf<long>(unsigned char const*)

Line

Count

Source

42

4.17k

template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {

43

4.17k

  auto item = Item();

44

4.17k

  std::memcpy(&item, data, sizeof(Item));

45

4.17k

  return item;

46

4.17k

}

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

Line

Count

Source

42

3.59k

template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {

43

3.59k

  auto item = Item();

44

3.59k

  std::memcpy(&item, data, sizeof(Item));

45

3.59k

  return item;

46

3.59k

}

float assign_from_buf<float>(unsigned char const*)

Line

Count

Source

42

5.03k

template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {

43

5.03k

  auto item = Item();

44

5.03k

  std::memcpy(&item, data, sizeof(Item));

45

5.03k

  return item;

46

5.03k

}

double assign_from_buf<double>(unsigned char const*)

Line

Count

Source

42

5.02k

template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {

43

5.02k

  auto item = Item();

44

5.02k

  std::memcpy(&item, data, sizeof(Item));

45

5.02k

  return item;

46

5.02k

}

long double assign_from_buf<long double>(unsigned char const*)

Line

Count

Source

42

5.13k

template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {

43

5.13k

  auto item = Item();

44

5.13k

  std::memcpy(&item, data, sizeof(Item));

45

5.13k

  return item;

46

5.13k

}

// Reads a boolean value by looking at the first byte from data.

template <> inline bool assign_from_buf<bool>(const std::uint8_t* data) {

  return *data != 0;

}

struct data_to_string {

#if FMT_FUZZ_SEPARATE_ALLOCATION

  std::vector<char> buffer;

  data_to_string(const uint8_t* data, size_t size, bool add_terminator = false)

      : buffer(size + (add_terminator ? 1 : 0)) {

    if (size) {

      std::memcpy(buffer.data(), data, size);

    }

  }

  fmt::string_view get() const { return {buffer.data(), buffer.size()}; }

#else

  fmt::string_view sv;

  data_to_string(const uint8_t* data, size_t size, bool = false)

      : str(as_chars(data), size) {}

  fmt::string_view get() const { return sv; }

#endif

  const char* data() const { return get().data(); }

};

#endif  // FUZZER_COMMON_H