This is an archive of the discontinued LLVM Phabricator instance.

Thanks for the comment! I was wondering about that, but haven't found any guidelines restricting or discouraging this. Also, I've seen some .hpp files in LLVM.

IMO .hpp makes much more sense for a header like this (C++ with implementation), especially given that it's a public header provided via "include" directory.

With all of that, I'd prefer setting up a precedent for respecting .hpp files, assuming that I'm not violating any strict requirements :)

In D65812#1617545, @Dor1s wrote:

Objection: .hpp is not idiomatic in LLVM.

Thanks for the comment! I was wondering about that, but haven't found any guidelines restricting or discouraging this. Also, I've seen some .hpp files in LLVM.

IMO .hpp makes much more sense for a header like this (C++ with implementation), especially given that it's a public header provided via "include" directory.

With all of that, I'd prefer setting up a precedent for respecting .hpp files, assuming that I'm not violating any strict requirements :)

$ git ls-files '*.hpp' | wc -l
      43
$ git ls-files '*.h' | wc -l
    7151

And almost all of the existing 43 hpp files are test inputs. So +1 to the objection – we virtually don't have .hpp files in LLVM.

In D65812#1620267, @thakis wrote:
In D65812#1617545, @Dor1s wrote:

Objection: .hpp is not idiomatic in LLVM.

Thanks for the comment! I was wondering about that, but haven't found any guidelines restricting or discouraging this. Also, I've seen some .hpp files in LLVM.

IMO .hpp makes much more sense for a header like this (C++ with implementation), especially given that it's a public header provided via "include" directory.

With all of that, I'd prefer setting up a precedent for respecting .hpp files, assuming that I'm not violating any strict requirements :)
$ git ls-files '*.hpp' | wc -l
      43
$ git ls-files '*.h' | wc -l
    7151
And almost all of the existing 43 hpp files are test inputs. So +1 to the objection – we virtually don't have .hpp files in LLVM.

Nico, thanks for taking a look too. Ok, I'll rename it back to \.h tomorrow. Some documented guidance and/or stronger consistency might be helpful for cases like this in future. I think I tried to be reasonable and it didn't seem like I was going to violate any rules :)

FTR, changed the extension back to .h in r368331.

Revision Contents

Path

Size

compiler-rt/

trunk/

include/

CMakeLists.txt

2 lines

fuzzer/

FuzzedDataProvider.h

245 lines

FuzzedDataProvider.hpp

245 lines

lib/

fuzzer/

tests/

FuzzedDataProviderUnittest.cpp

2 lines

utils/

FuzzedDataProvider.h

2 lines

sanitizer_common/

scripts/

check_lint.sh

2 lines

Diff 213631

compiler-rt/trunk/include/CMakeLists.txt

Show All 9 Lines	set(SANITIZER_HEADERS
sanitizer/lsan_interface.h		sanitizer/lsan_interface.h
sanitizer/msan_interface.h		sanitizer/msan_interface.h
sanitizer/netbsd_syscall_hooks.h		sanitizer/netbsd_syscall_hooks.h
sanitizer/scudo_interface.h		sanitizer/scudo_interface.h
sanitizer/tsan_interface.h		sanitizer/tsan_interface.h
sanitizer/tsan_interface_atomic.h		sanitizer/tsan_interface_atomic.h
)		)
set(FUZZER_HEADERS		set(FUZZER_HEADERS
fuzzer/FuzzedDataProvider.h		fuzzer/FuzzedDataProvider.hpp
)		)
endif(COMPILER_RT_BUILD_SANITIZERS)		endif(COMPILER_RT_BUILD_SANITIZERS)

if (COMPILER_RT_BUILD_XRAY)		if (COMPILER_RT_BUILD_XRAY)
set(XRAY_HEADERS		set(XRAY_HEADERS
xray/xray_interface.h		xray/xray_interface.h
xray/xray_log_interface.h		xray/xray_log_interface.h
xray/xray_records.h		xray/xray_records.h
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

compiler-rt/trunk/include/fuzzer/FuzzedDataProvider.h

	//===- FuzzedDataProvider.h - Utility header for fuzz targets ---- C++ - ===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	// A single header library providing an utility class to break up an array of
	// bytes. Whenever run on the same input, provides the same output, as long as
	// its methods are called in the same order, with the same arguments.
	//===----------------------------------------------------------------------===//

	#ifndef LLVM_FUZZER_FUZZED_DATA_PROVIDER_H_
	#define LLVM_FUZZER_FUZZED_DATA_PROVIDER_H_

	#include <limits.h>
	#include <stddef.h>
	#include <stdint.h>

	#include <algorithm>
	#include <cstring>
	#include <initializer_list>
	#include <string>
	#include <type_traits>
	#include <utility>
	#include <vector>

	class FuzzedDataProvider {
	public:
	// \|data\| is an array of length \|size\| that the FuzzedDataProvider wraps to
	// provide more granular access. \|data\| must outlive the FuzzedDataProvider.
	FuzzedDataProvider(const uint8_t *data, size_t size)
	: data_ptr_(data), remaining_bytes_(size) {}
	~FuzzedDataProvider() = default;

	// Returns a std::vector containing \|num_bytes\| of input data. If fewer than
	// \|num_bytes\| of data remain, returns a shorter std::vector containing all
	// of the data that's left. Can be used with any byte sized type, such as
	// char, unsigned char, uint8_t, etc.
	template <typename T> std::vector<T> ConsumeBytes(size_t num_bytes) {
	num_bytes = std::min(num_bytes, remaining_bytes_);
	return ConsumeBytes<T>(num_bytes, num_bytes);
	}

	// Similar to \|ConsumeBytes\|, but also appends the terminator value at the end
	// of the resulting vector. Useful, when a mutable null-terminated C-string is
	// needed, for example. But that is a rare case. Better avoid it, if possible,
	// and prefer using \|ConsumeBytes\| or \|ConsumeBytesAsString\| methods.
	template <typename T>
	std::vector<T> ConsumeBytesWithTerminator(size_t num_bytes,
	T terminator = 0) {
	num_bytes = std::min(num_bytes, remaining_bytes_);
	std::vector<T> result = ConsumeBytes<T>(num_bytes + 1, num_bytes);
	result.back() = terminator;
	return result;
	}

	// Returns a std::string containing \|num_bytes\| of input data. Using this and
	// \|.c_str()\| on the resulting string is the best way to get an immutable
	// null-terminated C string. If fewer than \|num_bytes\| of data remain, returns
	// a shorter std::string containing all of the data that's left.
	std::string ConsumeBytesAsString(size_t num_bytes) {
	static_assert(sizeof(std::string::value_type) == sizeof(uint8_t),
	"ConsumeBytesAsString cannot convert the data to a string.");

	num_bytes = std::min(num_bytes, remaining_bytes_);
	std::string result(
	reinterpret_cast<const std::string::value_type *>(data_ptr_),
	num_bytes);
	Advance(num_bytes);
	return result;
	}

	// Returns a number in the range [min, max] by consuming bytes from the
	// input data. The value might not be uniformly distributed in the given
	// range. If there's no input data left, always returns \|min\|. \|min\| must
	// be less than or equal to \|max\|.
	template <typename T> T ConsumeIntegralInRange(T min, T max) {
	static_assert(std::is_integral<T>::value, "An integral type is required.");
	static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");

	if (min > max)
	abort();

	// Use the biggest type possible to hold the range and the result.
	uint64_t range = static_cast<uint64_t>(max) - min;
	uint64_t result = 0;
	size_t offset = 0;

	while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
	remaining_bytes_ != 0) {
	// Pull bytes off the end of the seed data. Experimentally, this seems to
	// allow the fuzzer to more easily explore the input space. This makes
	// sense, since it works by modifying inputs that caused new code to run,
	// and this data is often used to encode length of data read by
	// \|ConsumeBytes\|. Separating out read lengths makes it easier modify the
	// contents of the data that is actually read.
	--remaining_bytes_;
	result = (result << CHAR_BIT) \| data_ptr_[remaining_bytes_];
	offset += CHAR_BIT;
	}

	// Avoid division by 0, in case \|range + 1\| results in overflow.
	if (range != std::numeric_limits<decltype(range)>::max())
	result = result % (range + 1);

	return static_cast<T>(min + result);
	}

	// Returns a std::string of length from 0 to \|max_length\|. When it runs out of
	// input data, returns what remains of the input. Designed to be more stable
	// with respect to a fuzzer inserting characters than just picking a random
	// length and then consuming that many bytes with \|ConsumeBytes\|.
	std::string ConsumeRandomLengthString(size_t max_length) {
	// Reads bytes from the start of \|data_ptr_\|. Maps "\\" to "\", and maps "\"
	// followed by anything else to the end of the string. As a result of this
	// logic, a fuzzer can insert characters into the string, and the string
	// will be lengthened to include those new characters, resulting in a more
	// stable fuzzer than picking the length of a string independently from
	// picking its contents.
	std::string result;

	// Reserve the anticipated capaticity to prevent several reallocations.
	result.reserve(std::min(max_length, remaining_bytes_));
	for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) {
	char next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
	Advance(1);
	if (next == '\\' && remaining_bytes_ != 0) {
	next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
	Advance(1);
	if (next != '\\')
	break;
	}
	result += next;
	}

	result.shrink_to_fit();
	return result;
	}

	// Returns a std::vector containing all remaining bytes of the input data.
	template <typename T> std::vector<T> ConsumeRemainingBytes() {
	return ConsumeBytes<T>(remaining_bytes_);
	}

	// Prefer using \|ConsumeRemainingBytes\| unless you actually need a std::string
	// object.
	// Returns a std::vector containing all remaining bytes of the input data.
	std::string ConsumeRemainingBytesAsString() {
	return ConsumeBytesAsString(remaining_bytes_);
	}

	// Returns a number in the range [Type's min, Type's max]. The value might
	// not be uniformly distributed in the given range. If there's no input data
	// left, always returns \|min\|.
	template <typename T> T ConsumeIntegral() {
	return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
	std::numeric_limits<T>::max());
	}

	// Reads one byte and returns a bool, or false when no data remains.
	bool ConsumeBool() { return 1 & ConsumeIntegral<uint8_t>(); }

	// Returns a copy of a value selected from a fixed-size \|array\|.
	template <typename T, size_t size>
	T PickValueInArray(const T (&array)[size]) {
	static_assert(size > 0, "The array must be non empty.");
	return array[ConsumeIntegralInRange<size_t>(0, size - 1)];
	}

	template <typename T>
	T PickValueInArray(std::initializer_list<const T> list) {
	// static_assert(list.size() > 0, "The array must be non empty.");
	return *(list.begin() + ConsumeIntegralInRange<size_t>(0, list.size() - 1));
	}

	// Return an enum value. The enum must start at 0 and be contiguous. It must
	// also contain \|kMaxValue\| aliased to its largest (inclusive) value. Such as:
	// enum class Foo { SomeValue, OtherValue, kMaxValue = OtherValue };
	template <typename T> T ConsumeEnum() {
	static_assert(std::is_enum<T>::value, "\|T\| must be an enum type.");
	return static_cast<T>(ConsumeIntegralInRange<uint32_t>(
	0, static_cast<uint32_t>(T::kMaxValue)));
	}

	// Reports the remaining bytes available for fuzzed input.
	size_t remaining_bytes() { return remaining_bytes_; }

	private:
	FuzzedDataProvider(const FuzzedDataProvider &) = delete;
	FuzzedDataProvider &operator=(const FuzzedDataProvider &) = delete;

	void Advance(size_t num_bytes) {
	if (num_bytes > remaining_bytes_)
	abort();

	data_ptr_ += num_bytes;
	remaining_bytes_ -= num_bytes;
	}

	template <typename T>
	std::vector<T> ConsumeBytes(size_t size, size_t num_bytes_to_consume) {
	static_assert(sizeof(T) == sizeof(uint8_t), "Incompatible data type.");

	// The point of using the size-based constructor below is to increase the
	// odds of having a vector object with capacity being equal to the length.
	// That part is always implementation specific, but at least both libc++ and
	// libstdc++ allocate the requested number of bytes in that constructor,
	// which seems to be a natural choice for other implementations as well.
	// To increase the odds even more, we also call \|shrink_to_fit\| below.
	std::vector<T> result(size);
	std::memcpy(result.data(), data_ptr_, num_bytes_to_consume);
	Advance(num_bytes_to_consume);

	// Even though \|shrink_to_fit\| is also implementation specific, we expect it
	// to provide an additional assurance in case vector's constructor allocated
	// a buffer which is larger than the actual amount of data we put inside it.
	result.shrink_to_fit();
	return result;
	}

	template <typename TS, typename TU> TS ConvertUnsignedToSigned(TU value) {
	static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types.");
	static_assert(!std::numeric_limits<TU>::is_signed,
	"Source type must be unsigned.");

	// TODO(Dor1s): change to `if constexpr` once C++17 becomes mainstream.
	if (std::numeric_limits<TS>::is_modulo)
	return static_cast<TS>(value);

	// Avoid using implementation-defined unsigned to signer conversions.
	// To learn more, see https://stackoverflow.com/questions/13150449.
	if (value <= std::numeric_limits<TS>::max())
	return static_cast<TS>(value);
	else {
	constexpr auto TS_min = std::numeric_limits<TS>::min();
	return TS_min + static_cast<char>(value - TS_min);
	}
	}

	const uint8_t *data_ptr_;
	size_t remaining_bytes_;
	};

	#endif // LLVM_FUZZER_FUZZED_DATA_PROVIDER_H_

compiler-rt/trunk/include/fuzzer/FuzzedDataProvider.hpp

				//===- FuzzedDataProvider.hpp - Utility header for fuzz targets -- C++ - ===//
				//
				// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
				// See https://llvm.org/LICENSE.txt for license information.
				// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
				//
				//===----------------------------------------------------------------------===//
				// A single header library providing an utility class to break up an array of
				// bytes. Whenever run on the same input, provides the same output, as long as
				// its methods are called in the same order, with the same arguments.
				//===----------------------------------------------------------------------===//

				#ifndef LLVM_FUZZER_FUZZED_DATA_PROVIDER_H_
				#define LLVM_FUZZER_FUZZED_DATA_PROVIDER_H_

				#include <limits.h>
				#include <stddef.h>
				#include <stdint.h>

				#include <algorithm>
				#include <cstring>
				#include <initializer_list>
				#include <string>
				#include <type_traits>
				#include <utility>
				#include <vector>

				class FuzzedDataProvider {
				public:
				// \|data\| is an array of length \|size\| that the FuzzedDataProvider wraps to
				// provide more granular access. \|data\| must outlive the FuzzedDataProvider.
				FuzzedDataProvider(const uint8_t *data, size_t size)
				: data_ptr_(data), remaining_bytes_(size) {}
				~FuzzedDataProvider() = default;

				// Returns a std::vector containing \|num_bytes\| of input data. If fewer than
				// \|num_bytes\| of data remain, returns a shorter std::vector containing all
				// of the data that's left. Can be used with any byte sized type, such as
				// char, unsigned char, uint8_t, etc.
				template <typename T> std::vector<T> ConsumeBytes(size_t num_bytes) {
				num_bytes = std::min(num_bytes, remaining_bytes_);
				return ConsumeBytes<T>(num_bytes, num_bytes);
				}

				// Similar to \|ConsumeBytes\|, but also appends the terminator value at the end
				// of the resulting vector. Useful, when a mutable null-terminated C-string is
				// needed, for example. But that is a rare case. Better avoid it, if possible,
				// and prefer using \|ConsumeBytes\| or \|ConsumeBytesAsString\| methods.
				template <typename T>
				std::vector<T> ConsumeBytesWithTerminator(size_t num_bytes,
				T terminator = 0) {
				num_bytes = std::min(num_bytes, remaining_bytes_);
				std::vector<T> result = ConsumeBytes<T>(num_bytes + 1, num_bytes);
				result.back() = terminator;
				return result;
				}

				// Returns a std::string containing \|num_bytes\| of input data. Using this and
				// \|.c_str()\| on the resulting string is the best way to get an immutable
				// null-terminated C string. If fewer than \|num_bytes\| of data remain, returns
				// a shorter std::string containing all of the data that's left.
				std::string ConsumeBytesAsString(size_t num_bytes) {
				static_assert(sizeof(std::string::value_type) == sizeof(uint8_t),
				"ConsumeBytesAsString cannot convert the data to a string.");

				num_bytes = std::min(num_bytes, remaining_bytes_);
				std::string result(
				reinterpret_cast<const std::string::value_type *>(data_ptr_),
				num_bytes);
				Advance(num_bytes);
				return result;
				}

				// Returns a number in the range [min, max] by consuming bytes from the
				// input data. The value might not be uniformly distributed in the given
				// range. If there's no input data left, always returns \|min\|. \|min\| must
				// be less than or equal to \|max\|.
				template <typename T> T ConsumeIntegralInRange(T min, T max) {
				static_assert(std::is_integral<T>::value, "An integral type is required.");
				static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");

				if (min > max)
				abort();

				// Use the biggest type possible to hold the range and the result.
				uint64_t range = static_cast<uint64_t>(max) - min;
				uint64_t result = 0;
				size_t offset = 0;

				while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
				remaining_bytes_ != 0) {
				// Pull bytes off the end of the seed data. Experimentally, this seems to
				// allow the fuzzer to more easily explore the input space. This makes
				// sense, since it works by modifying inputs that caused new code to run,
				// and this data is often used to encode length of data read by
				// \|ConsumeBytes\|. Separating out read lengths makes it easier modify the
				// contents of the data that is actually read.
				--remaining_bytes_;
				result = (result << CHAR_BIT) \| data_ptr_[remaining_bytes_];
				offset += CHAR_BIT;
				}

				// Avoid division by 0, in case \|range + 1\| results in overflow.
				if (range != std::numeric_limits<decltype(range)>::max())
				result = result % (range + 1);

				return static_cast<T>(min + result);
				}

				// Returns a std::string of length from 0 to \|max_length\|. When it runs out of
				// input data, returns what remains of the input. Designed to be more stable
				// with respect to a fuzzer inserting characters than just picking a random
				// length and then consuming that many bytes with \|ConsumeBytes\|.
				std::string ConsumeRandomLengthString(size_t max_length) {
				// Reads bytes from the start of \|data_ptr_\|. Maps "\\" to "\", and maps "\"
				// followed by anything else to the end of the string. As a result of this
				// logic, a fuzzer can insert characters into the string, and the string
				// will be lengthened to include those new characters, resulting in a more
				// stable fuzzer than picking the length of a string independently from
				// picking its contents.
				std::string result;

				// Reserve the anticipated capaticity to prevent several reallocations.
				result.reserve(std::min(max_length, remaining_bytes_));
				for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) {
				char next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
				Advance(1);
				if (next == '\\' && remaining_bytes_ != 0) {
				next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
				Advance(1);
				if (next != '\\')
				break;
				}
				result += next;
				}

				result.shrink_to_fit();
				return result;
				}

				// Returns a std::vector containing all remaining bytes of the input data.
				template <typename T> std::vector<T> ConsumeRemainingBytes() {
				return ConsumeBytes<T>(remaining_bytes_);
				}

				// Prefer using \|ConsumeRemainingBytes\| unless you actually need a std::string
				// object.
				// Returns a std::vector containing all remaining bytes of the input data.
				std::string ConsumeRemainingBytesAsString() {
				return ConsumeBytesAsString(remaining_bytes_);
				}

				// Returns a number in the range [Type's min, Type's max]. The value might
				// not be uniformly distributed in the given range. If there's no input data
				// left, always returns \|min\|.
				template <typename T> T ConsumeIntegral() {
				return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
				std::numeric_limits<T>::max());
				}

				// Reads one byte and returns a bool, or false when no data remains.
				bool ConsumeBool() { return 1 & ConsumeIntegral<uint8_t>(); }

				// Returns a copy of a value selected from a fixed-size \|array\|.
				template <typename T, size_t size>
				T PickValueInArray(const T (&array)[size]) {
				static_assert(size > 0, "The array must be non empty.");
				return array[ConsumeIntegralInRange<size_t>(0, size - 1)];
				}

				template <typename T>
				T PickValueInArray(std::initializer_list<const T> list) {
				// static_assert(list.size() > 0, "The array must be non empty.");
				return *(list.begin() + ConsumeIntegralInRange<size_t>(0, list.size() - 1));
				}

				// Return an enum value. The enum must start at 0 and be contiguous. It must
				// also contain \|kMaxValue\| aliased to its largest (inclusive) value. Such as:
				// enum class Foo { SomeValue, OtherValue, kMaxValue = OtherValue };
				template <typename T> T ConsumeEnum() {
				static_assert(std::is_enum<T>::value, "\|T\| must be an enum type.");
				return static_cast<T>(ConsumeIntegralInRange<uint32_t>(
				0, static_cast<uint32_t>(T::kMaxValue)));
				}

				// Reports the remaining bytes available for fuzzed input.
				size_t remaining_bytes() { return remaining_bytes_; }

				private:
				FuzzedDataProvider(const FuzzedDataProvider &) = delete;
				FuzzedDataProvider &operator=(const FuzzedDataProvider &) = delete;

				void Advance(size_t num_bytes) {
				if (num_bytes > remaining_bytes_)
				abort();

				data_ptr_ += num_bytes;
				remaining_bytes_ -= num_bytes;
				}

				template <typename T>
				std::vector<T> ConsumeBytes(size_t size, size_t num_bytes_to_consume) {
				static_assert(sizeof(T) == sizeof(uint8_t), "Incompatible data type.");

				// The point of using the size-based constructor below is to increase the
				// odds of having a vector object with capacity being equal to the length.
				// That part is always implementation specific, but at least both libc++ and
				// libstdc++ allocate the requested number of bytes in that constructor,
				// which seems to be a natural choice for other implementations as well.
				// To increase the odds even more, we also call \|shrink_to_fit\| below.
				std::vector<T> result(size);
				std::memcpy(result.data(), data_ptr_, num_bytes_to_consume);
				Advance(num_bytes_to_consume);

				// Even though \|shrink_to_fit\| is also implementation specific, we expect it
				// to provide an additional assurance in case vector's constructor allocated
				// a buffer which is larger than the actual amount of data we put inside it.
				result.shrink_to_fit();
				return result;
				}

				template <typename TS, typename TU> TS ConvertUnsignedToSigned(TU value) {
				static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types.");
				static_assert(!std::numeric_limits<TU>::is_signed,
				"Source type must be unsigned.");

				// TODO(Dor1s): change to `if constexpr` once C++17 becomes mainstream.
				if (std::numeric_limits<TS>::is_modulo)
				return static_cast<TS>(value);

				// Avoid using implementation-defined unsigned to signer conversions.
				// To learn more, see https://stackoverflow.com/questions/13150449.
				if (value <= std::numeric_limits<TS>::max())
				return static_cast<TS>(value);
				else {
				constexpr auto TS_min = std::numeric_limits<TS>::min();
				return TS_min + static_cast<char>(value - TS_min);
				}
				}

				const uint8_t *data_ptr_;
				size_t remaining_bytes_;
				};

				#endif // LLVM_FUZZER_FUZZED_DATA_PROVIDER_H_

compiler-rt/trunk/lib/fuzzer/tests/FuzzedDataProviderUnittest.cpp

	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

	#include "gtest/gtest.h"			#include "gtest/gtest.h"
	#include <cstdint>			#include <cstdint>
	#include <cstdlib>			#include <cstdlib>

	#include <fuzzer/FuzzedDataProvider.h>			#include <fuzzer/FuzzedDataProvider.hpp>

	// The test is intentionally extensive, as behavior of \|FuzzedDataProvider\| must			// The test is intentionally extensive, as behavior of \|FuzzedDataProvider\| must
	// not be broken, given than many fuzz targets depend on it. Changing the			// not be broken, given than many fuzz targets depend on it. Changing the
	// behavior might invalidate existing corpora and make the fuzz targets using			// behavior might invalidate existing corpora and make the fuzz targets using
	// \|FuzzedDataProvider\| to lose code coverage accumulated over time.			// \|FuzzedDataProvider\| to lose code coverage accumulated over time.

	/* A random 1KB buffer generated by:			/* A random 1KB buffer generated by:
	$ python -c "import os; print ',\n'.join([', '.join(['0x%02X' % ord(i) for i \			$ python -c "import os; print ',\n'.join([', '.join(['0x%02X' % ord(i) for i \
	▲ Show 20 Lines • Show All 337 Lines • Show Last 20 Lines

compiler-rt/trunk/lib/fuzzer/utils/FuzzedDataProvider.h

	//===- FuzzedDataProvider.h - Utility header for fuzz targets ---- C++ - ===//			//===- FuzzedDataProvider.h - Utility header for fuzz targets ---- C++ - ===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//
				// This a temporary copy of compiler-rt/include/fuzzer/FuzzedDataProvider.hpp.
				// TODO(mmoroz@chromium.org): delete this copy.
	// A single header library providing an utility class to break up an array of			// A single header library providing an utility class to break up an array of
	// bytes. Whenever run on the same input, provides the same output, as long as			// bytes. Whenever run on the same input, provides the same output, as long as
	// its methods are called in the same order, with the same arguments.			// its methods are called in the same order, with the same arguments.
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#ifndef LLVM_FUZZER_FUZZED_DATA_PROVIDER_H_			#ifndef LLVM_FUZZER_FUZZED_DATA_PROVIDER_H_
	#define LLVM_FUZZER_FUZZED_DATA_PROVIDER_H_			#define LLVM_FUZZER_FUZZED_DATA_PROVIDER_H_

	▲ Show 20 Lines • Show All 230 Lines • Show Last 20 Lines

compiler-rt/trunk/lib/sanitizer_common/scripts/check_lint.sh

	Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
	if [ "${COMPILER_RT}" = "" ]; then			if [ "${COMPILER_RT}" = "" ]; then
	COMPILER_RT=projects/compiler-rt			COMPILER_RT=projects/compiler-rt
	fi			fi
	LIT_TESTS=${COMPILER_RT}/test			LIT_TESTS=${COMPILER_RT}/test
	# Headers			# Headers
	SANITIZER_INCLUDES=${COMPILER_RT}/include/sanitizer			SANITIZER_INCLUDES=${COMPILER_RT}/include/sanitizer
	FUZZER_INCLUDES=${COMPILER_RT}/include/fuzzer			FUZZER_INCLUDES=${COMPILER_RT}/include/fuzzer
	run_lint ${SANITIZER_INCLUDES_LINT_FILTER} ${SANITIZER_INCLUDES}/*.h \			run_lint ${SANITIZER_INCLUDES_LINT_FILTER} ${SANITIZER_INCLUDES}/*.h \
	${FUZZER_INCLUDES}/*.h &			${FUZZER_INCLUDES}/*.hpp &

	# Sanitizer_common			# Sanitizer_common
	COMMON_RTL=${COMPILER_RT}/lib/sanitizer_common			COMMON_RTL=${COMPILER_RT}/lib/sanitizer_common
	run_lint ${COMMON_RTL_INC_LINT_FILTER} ${COMMON_RTL}/*.cpp \			run_lint ${COMMON_RTL_INC_LINT_FILTER} ${COMMON_RTL}/*.cpp \
	${COMMON_RTL}/*.h \			${COMMON_RTL}/*.h \
	${COMMON_RTL}/tests/*.cpp &			${COMMON_RTL}/tests/*.cpp &

	# Interception			# Interception
	▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

[compiler-rt] Rename FuzzedDataProvider.h to .hpp and other minor changes.ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 213631

compiler-rt/trunk/include/CMakeLists.txt

compiler-rt/trunk/include/fuzzer/FuzzedDataProvider.h

compiler-rt/trunk/include/fuzzer/FuzzedDataProvider.hpp

compiler-rt/trunk/lib/fuzzer/tests/FuzzedDataProviderUnittest.cpp

compiler-rt/trunk/lib/fuzzer/utils/FuzzedDataProvider.h

compiler-rt/trunk/lib/sanitizer_common/scripts/check_lint.sh

[compiler-rt] Rename FuzzedDataProvider.h to .hpp and other minor changes.
ClosedPublic