Differential D42519 Diff 132485 test/scudo/realloc.cpp

Changeset View

Standalone View

test/scudo/realloc.cpp

	Show All 9 Lines
	// size of the old chunk to the new one (as opposed to the requested size).			// size of the old chunk to the new one (as opposed to the requested size).

	#include <assert.h>			#include <assert.h>
	#include <malloc.h>			#include <malloc.h>
	#include <string.h>			#include <string.h>

	#include <vector>			#include <vector>

				#include <sanitizer/allocator_interface.h>

	int main(int argc, char **argv)			int main(int argc, char **argv)
	{			{
	void p, old_p;			void p, old_p;
	// Those sizes will exercise both allocators (Primary & Secondary).			// Those sizes will exercise both allocators (Primary & Secondary).
	std::vector<size_t> sizes{1, 16, 1024, 32768, 1 << 16, 1 << 17, 1 << 20};			std::vector<size_t> sizes{1, 16, 1024, 32768, 1 << 16, 1 << 17, 1 << 20};

	assert(argc == 2);			assert(argc == 2);

	if (!strcmp(argv[1], "usablesize")) {			if (!strcmp(argv[1], "usablesize")) {
	// This tests a sketchy behavior inherited from poorly written libraries			// This tests a sketchy behavior inherited from poorly written libraries
	// that have become somewhat standard. When realloc'ing a chunk, the			// that have become somewhat standard. When realloc'ing a chunk, the
	// copied contents should span the usable size of the chunk, not the			// copied contents should span the usable size of the chunk, not the
	// requested size.			// requested size.
	size_t size = 496, usable_size;			size_t size = 496, usable_size;
	p = nullptr;			p = nullptr;
	// Make sure we get a chunk with a usable size actually larger than size.			// Make sure we get a chunk with a usable size actually larger than size.
	do {			do {
	if (p) free(p);			if (p) free(p);
	size += 16;			size += 16;
	p = malloc(size);			p = malloc(size);
	usable_size = malloc_usable_size(p);			usable_size = __sanitizer_get_allocated_size(p);
	assert(usable_size >= size);			assert(usable_size >= size);
	} while (usable_size == size);			} while (usable_size == size);
	for (int i = 0; i < usable_size; i++)			for (int i = 0; i < usable_size; i++)
	reinterpret_cast<char *>(p)[i] = 'A';			reinterpret_cast<char *>(p)[i] = 'A';
	old_p = p;			old_p = p;
	// Make sure we get a different chunk so that the data is actually copied.			// Make sure we get a different chunk so that the data is actually copied.
	do {			do {
	size *= 2;			size *= 2;
	p = realloc(p, size);			p = realloc(p, size);
	assert(p);			assert(p);
	} while (p == old_p);			} while (p == old_p);
	// The contents of the new chunk must match the old one up to usable_size.			// The contents of the new chunk must match the old one up to usable_size.
	for (int i = 0; i < usable_size; i++)			for (int i = 0; i < usable_size; i++)
	assert(reinterpret_cast<char *>(p)[i] == 'A');			assert(reinterpret_cast<char *>(p)[i] == 'A');
	free(p);			free(p);
	} else {			} else {
	for (size_t size : sizes) {			for (size_t size : sizes) {
	if (!strcmp(argv[1], "pointers")) {			if (!strcmp(argv[1], "pointers")) {
	old_p = p = realloc(nullptr, size);			old_p = p = realloc(nullptr, size);
	assert(p);			assert(p);
	size = malloc_usable_size(p);			size = __sanitizer_get_allocated_size(p);
	// Our realloc implementation will return the same pointer if the size			// Our realloc implementation will return the same pointer if the size
	// requested is lower than or equal to the usable size of the associated			// requested is lower than or equal to the usable size of the associated
	// chunk.			// chunk.
	p = realloc(p, size - 1);			p = realloc(p, size - 1);
	assert(p == old_p);			assert(p == old_p);
	p = realloc(p, size);			p = realloc(p, size);
	assert(p == old_p);			assert(p == old_p);
	// And a new one if the size is greater.			// And a new one if the size is greater.
	Show All 23 Lines