Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 2003 - 2005 Pekka Riikonen
+ Copyright (C) 2003 - 2008 Pekka Riikonen
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/* #define SILC_STACK_DEBUG 1 */
-#include "silcincludes.h"
+#include "silc.h"
/* Allocate the stack */
{
int i;
+ if (!stack)
+ return;
+
silc_free(stack->frames);
for (i = 0; i < SILC_STACK_BLOCK_NUM; i++)
silc_free(stack->stack[i]);
memory, otherwise memory is aligned. Returns pointer to the memory
or NULL on error. */
-void *silc_stack_malloc(SilcStack stack, SilcUInt32 size, bool aligned)
+void *silc_stack_malloc(SilcStack stack, SilcUInt32 size, SilcBool aligned)
{
void *ptr;
SilcUInt32 bsize, bsize2;
SILC_ST_DEBUG(("Allocating %d bytes (%s) from %p",
size, aligned ? "align" : "not align", stack));
- if (!size) {
+ if (silc_unlikely(!size)) {
SILC_LOG_ERROR(("Allocation by zero (0)"));
SILC_STACK_STAT(stack, num_errors, 1);
return NULL;
}
- if (size > SILC_STACK_MAX_ALLOC) {
+ if (silc_unlikely(size > SILC_STACK_MAX_ALLOC)) {
SILC_LOG_ERROR(("Allocating too much"));
SILC_STACK_STAT(stack, num_errors, 1);
return NULL;
bsize2 <<= 1;
si++;
}
- if (si >= SILC_STACK_BLOCK_NUM) {
+ if (silc_unlikely(si >= SILC_STACK_BLOCK_NUM)) {
SILC_LOG_ERROR(("Allocating too large block"));
SILC_STACK_STAT(stack, num_errors, 1);
return NULL;
stack->stack[si] = silc_malloc(bsize2 +
SILC_STACK_ALIGN(sizeof(**stack->stack),
SILC_STACK_DEFAULT_ALIGN));
- if (!stack->stack[si]) {
+ if (silc_unlikely(!stack->stack[si])) {
SILC_STACK_STAT(stack, num_errors, 1);
return NULL;
}
the old memory remains intact. */
void *silc_stack_realloc(SilcStack stack, SilcUInt32 old_size,
- void *ptr, SilcUInt32 size, bool aligned)
+ void *ptr, SilcUInt32 size, SilcBool aligned)
{
SilcUInt32 si = stack->frame->si;
SilcUInt32 bsize;
SILC_ST_DEBUG(("Reallocating %d bytes (%d) (%s) from %p", size, old_size,
aligned ? "align" : "not align", stack));
- if (!size || !old_size) {
+ if (silc_unlikely(!size || !old_size)) {
SILC_LOG_ERROR(("Allocation by zero (0)"));
SILC_STACK_STAT(stack, num_errors, 1);
return NULL;
}
- if (size > SILC_STACK_MAX_ALLOC) {
+ if (silc_unlikely(size > SILC_STACK_MAX_ALLOC)) {
SILC_LOG_ERROR(("Allocating too much"));
SILC_STACK_STAT(stack, num_errors, 1);
return NULL;
/* Align the old size if needed */
old_size = (aligned ?
- SILC_STACK_ALIGN(old_size, SILC_STACK_DEFAULT_ALIGN) : old_size);
+ SILC_STACK_ALIGN(old_size,
+ SILC_STACK_DEFAULT_ALIGN) : old_size);
/* Compute the size of current stack block */
bsize = SILC_STACK_BLOCK_SIZE(stack, si);
/* Check that `ptr' is last allocation */
sptr = (unsigned char *)stack->stack[si] +
SILC_STACK_ALIGN(sizeof(**stack->stack), SILC_STACK_DEFAULT_ALIGN);
- if (stack->stack[si]->bytes_left + old_size + (ptr - sptr) != bsize) {
+ if (stack->stack[si]->bytes_left + old_size +
+ ((unsigned char *)ptr - (unsigned char *)sptr) != bsize) {
SILC_LOG_DEBUG(("Cannot reallocate"));
SILC_STACK_STAT(stack, num_errors, 1);
return NULL;
/* Now check that the new size fits to this block */
if (stack->stack[si]->bytes_left >= size) {
/* It fits, so simply return the old pointer */
- size = (aligned ? SILC_STACK_ALIGN(size, SILC_STACK_DEFAULT_ALIGN) : size);
+ size = (aligned ? SILC_STACK_ALIGN(size,
+ SILC_STACK_DEFAULT_ALIGN) : size);
stack->stack[si]->bytes_left -= (size - old_size);
SILC_STACK_STAT(stack, bytes_malloc, (size - old_size));
return ptr;