klish/lub/heap/heap_align_block.c

#include <assert.h>
#include "private.h"
#include "context.h"
#include "node.h"

/*--------------------------------------------------------- */
static void
lub_heap_free_leading_memory(lub_heap_t * this,
			     lub_heap_block_t * block, size_t size)
{
	lub_heap_block_t *prev_block = lub_heap_block_getprevious(block);
	if (prev_block && prev_block->free.tag.free) {
		/* 
		 * add the excess bytes to a preceeding free block
		 */
		lub_heap_graft_to_top(this,
				      prev_block,
				      block,
				      (size >> 2), BOOL_FALSE, BOOL_FALSE);
	} else {
		/*
		 * convert the excess bytes into a free block
		 */
		lub_heap_init_free_block(this,
					 block,
					 size,
					 block->alloc.tag.segment, BOOL_FALSE);
	}
	this->stats.alloc_bytes -= size;
}

/*--------------------------------------------------------- */
static void
lub_heap_free_trailing_memory(lub_heap_t * this,
			      lub_heap_block_t * block, size_t size)
{
	bool_t done = BOOL_FALSE;
	lub_heap_block_t *next_block = lub_heap_block_getnext(block);
	lub_heap_tag_t *tail = lub_heap_block__get_tail(block);
	char *ptr = (char *)&tail[1] - size;
	if (next_block && next_block->free.tag.free) {
		/* 
		 * try and add the excess bytes to a following free block
		 */
		lub_heap_graft_to_bottom(this,
					 next_block,
					 ptr,
					 (size >> 2), BOOL_FALSE, BOOL_FALSE);
		done = BOOL_TRUE;
	} else if (size >= sizeof(lub_heap_free_block_t)) {
		/*
		 * convert the excess bytes into a free block
		 */
		lub_heap_init_free_block(this,
					 ptr, size, BOOL_FALSE, tail->segment);
		done = BOOL_TRUE;
	}

	if (done) {
		/* correct the word count for the block */
		block->alloc.tag.words -= (size >> 2);
		tail = lub_heap_block__get_tail(block);
		tail->segment = 0;
		tail->free = 0;
		tail->words = block->alloc.tag.words;

		this->stats.alloc_bytes -= size;
	}
}

/*--------------------------------------------------------- */
void
lub_heap_align_block(lub_heap_t * this,
		     lub_heap_align_t alignment, char **ptr, size_t * size)
{
	if (*ptr) {
		lub_heap_block_t *block = lub_heap_block_from_ptr(*ptr);
		lub_heap_block_t *new_block;
		lub_heap_tag_t *new_tail;
		/* find the second occurance of an alignment boundary */
		size_t tmp = (alignment - 1);
		char *new_ptr =
		    (char *)(((size_t) * ptr + tmp + alignment) & ~tmp);
		size_t leading_bytes = (new_ptr - *ptr);
		size_t trailing_bytes;

		/* check this is a allocated block */
		assert(0 == block->alloc.tag.free);
		/*
		 * We MUST have left sufficient space to fit a free block and
		 * leak dection node if necessary.
		 */
		assert(leading_bytes >=
		       (sizeof(lub_heap_free_block_t) +
			sizeof(lub_heap_node_t)));

		if ((0 < lub_heap_frame_count) && (0 == this->suppress)) {
			/* 
			 * If leak detection is enabled then offset the pointer back by the size of 
			 * a lub_heap_node; which will be filled out by lub_heap_post_realloc()
			 */
			new_ptr -= sizeof(lub_heap_node_t);
			leading_bytes -= sizeof(lub_heap_node_t);
		}
		/*
		 * Create a new header just before the new pointer
		 */
		new_block = lub_heap_block_from_ptr(new_ptr);
		new_block->alloc.tag.free = 0;
		new_block->alloc.tag.segment = 0;
		new_block->alloc.tag.words =
		    block->alloc.tag.words - (leading_bytes >> 2);

		/* fix the size in the tail */
		new_tail = lub_heap_block__get_tail(new_block);
		new_tail->words = new_block->alloc.tag.words;

		lub_heap_free_leading_memory(this, block, leading_bytes);

		/* identify any trailing excess memory */
		trailing_bytes =
		    (new_block->alloc.tag.words << 2) - (*size -
							 (alignment << 1));

		if (trailing_bytes) {
			lub_heap_free_trailing_memory(this,
						      new_block,
						      trailing_bytes);
		}
		*size = (new_block->alloc.tag.words << 2);	/* size including the lub_heap_alloc_block_t details */
		*ptr = new_ptr;
	}
}