source: trunk/libs/newlib/src/newlib/libc/machine/xstormy16/tiny-malloc.c @ 444

/* A replacement malloc with:
   - Much reduced code size;
   - Smaller RAM footprint;
   - The ability to handle downward-growing heaps;
   but
   - Slower;
   - Probably higher memory fragmentation;
   - Doesn't support threads (but, if it did support threads,
     it wouldn't need a global lock, only a compare-and-swap instruction);
   - Assumes the maximum alignment required is the alignment of a pointer;
   - Assumes that memory is already there and doesn't need to be allocated.

* Synopsis of public routines

  malloc(size_t n);
     Return a pointer to a newly allocated chunk of at least n bytes, or null
     if no space is available.
  free(void* p);
     Release the chunk of memory pointed to by p, or no effect if p is null.
  realloc(void* p, size_t n);
     Return a pointer to a chunk of size n that contains the same data
     as does chunk p up to the minimum of (n, p's size) bytes, or null
     if no space is available. The returned pointer may or may not be
     the same as p. If p is null, equivalent to malloc.  Unless the
     #define REALLOC_ZERO_BYTES_FREES below is set, realloc with a
     size argument of zero (re)allocates a minimum-sized chunk.
  memalign(size_t alignment, size_t n);
     Return a pointer to a newly allocated chunk of n bytes, aligned
     in accord with the alignment argument, which must be a power of
     two.  Will fail if 'alignment' is too large.
  calloc(size_t unit, size_t quantity);
     Returns a pointer to quantity * unit bytes, with all locations
     set to zero.
  cfree(void* p);
     Equivalent to free(p).
  malloc_trim(size_t pad);
     Release all but pad bytes of freed top-most memory back 
     to the system. Return 1 if successful, else 0.
  malloc_usable_size(void* p);
     Report the number usable allocated bytes associated with allocated
     chunk p. This may or may not report more bytes than were requested,
     due to alignment and minimum size constraints.
  malloc_stats();
     Prints brief summary statistics on stderr.
  mallinfo()
     Returns (by copy) a struct containing various summary statistics.
  mallopt(int parameter_number, int parameter_value)
     Changes one of the tunable parameters described below. Returns
     1 if successful in changing the parameter, else 0.  Actually, returns 0
     always, as no parameter can be changed.
*/

#ifdef __xstormy16__
#define MALLOC_DIRECTION -1
#endif

#ifndef MALLOC_DIRECTION
#define MALLOC_DIRECTION 1
#endif

#include <stddef.h>

void* malloc(size_t);
void    free(void*);
void* realloc(void*, size_t);
void* memalign(size_t, size_t);
void* valloc(size_t);
void* pvalloc(size_t);
void* calloc(size_t, size_t);
void    cfree(void*);
int     malloc_trim(size_t);
size_t  malloc_usable_size(void*);
void    malloc_stats(void);
int     mallopt(int, int);
struct mallinfo mallinfo(void);

typedef struct freelist_entry {
  size_t size;
  struct freelist_entry *next;
} *fle;

extern void * __malloc_end;
extern fle __malloc_freelist;

/* Return the number of bytes that need to be added to X to make it
   aligned to an ALIGN boundary.  ALIGN must be a power of 2.  */
#define M_ALIGN(x, align) (-(size_t)(x) & ((align) - 1))

/* Return the number of bytes that need to be subtracted from X to make it
   aligned to an ALIGN boundary.  ALIGN must be a power of 2.  */
#define M_ALIGN_SUB(x, align) ((size_t)(x) & ((align) - 1))

extern void __malloc_start;

/* This is the minimum gap allowed between __malloc_end and the top of
   the stack.  This is only checked for when __malloc_end is
   decreased; if instead the stack grows into the heap, silent data
   corruption will result.  */
#define MALLOC_MINIMUM_GAP 32

#ifdef __xstormy16__
register void * stack_pointer asm ("r15");
#define MALLOC_LIMIT stack_pointer
#else
#define MALLOC_LIMIT __builtin_frame_address (0)
#endif

#if MALLOC_DIRECTION < 0
#define CAN_ALLOC_P(required)                           \
  (((size_t) __malloc_end - (size_t)MALLOC_LIMIT        \
    - MALLOC_MINIMUM_GAP) >= (required))
#else
#define CAN_ALLOC_P(required)                           \
  (((size_t)MALLOC_LIMIT - (size_t) __malloc_end        \
    - MALLOC_MINIMUM_GAP) >= (required))
#endif

/* real_size is the size we actually have to allocate, allowing for
   overhead and alignment.  */
#define REAL_SIZE(sz)                                           \
  ((sz) < sizeof (struct freelist_entry) - sizeof (size_t)      \
   ? sizeof (struct freelist_entry)                             \
   : sz + sizeof (size_t) + M_ALIGN(sz, sizeof (size_t)))

#ifdef DEFINE_MALLOC

void * __malloc_end = &__malloc_start;
fle __malloc_freelist;

void *
malloc (size_t sz)
{
  fle *nextfree;
  fle block;

  /* real_size is the size we actually have to allocate, allowing for
     overhead and alignment.  */
  size_t real_size = REAL_SIZE (sz);

  /* Look for the first block on the freelist that is large enough.  */
  for (nextfree = &__malloc_freelist; 
       *nextfree; 
       nextfree = &(*nextfree)->next)  
    {
      block = *nextfree;
      
      if (block->size >= real_size)
        {
          /* If the block found is just the right size, remove it from
             the free list.  Otherwise, split it.  */
          if (block->size < real_size + sizeof (struct freelist_entry))
            {
              *nextfree = block->next;
              return (void *)&block->next;
            }
          else
            {
              size_t newsize = block->size - real_size;
              fle newnext = block->next;
              *nextfree = (fle)((size_t)block + real_size);
              (*nextfree)->size = newsize;
              (*nextfree)->next = newnext;
              goto done;
            }
        }

      /* If this is the last block on the freelist, and it was too small,
         enlarge it.  */
      if (! block->next
          && __malloc_end == (void *)((size_t)block + block->size))
        {
          size_t moresize = real_size - block->size;
          if (! CAN_ALLOC_P (moresize))
            return NULL;
          
          *nextfree = NULL;
          if (MALLOC_DIRECTION < 0)
            {
              block = __malloc_end = (void *)((size_t)block - moresize);
            }
          else
            {
              __malloc_end = (void *)((size_t)block + real_size);
            }

          goto done;
        }
    }

  /* No free space at the end of the free list.  Allocate new space
     and use that.  */

  if (! CAN_ALLOC_P (real_size))
    return NULL;

  if (MALLOC_DIRECTION > 0)
    {
      block = __malloc_end;
      __malloc_end = (void *)((size_t)__malloc_end + real_size);
    }
  else
    {
      block = __malloc_end = (void *)((size_t)__malloc_end - real_size);
    }
 done:
  block->size = real_size;
  return (void *)&block->next;
}

#endif

#ifdef DEFINE_FREE

void
free (void *block_p)
{
  fle *nextfree;
  fle block = (fle)((size_t) block_p - offsetof (struct freelist_entry, next));

  if (block_p == NULL)
    return;
  
  /* Look on the freelist to see if there's a free block just before
     or just after this block.  */
  for (nextfree = &__malloc_freelist; 
       *nextfree; 
       nextfree = &(*nextfree)->next)
    {
      fle thisblock = *nextfree;
      if ((size_t)thisblock + thisblock->size == (size_t) block)
        {
          thisblock->size += block->size;
          if (MALLOC_DIRECTION > 0
              && thisblock->next
              && (size_t) block + block->size == (size_t) thisblock->next)
            {
              thisblock->size += thisblock->next->size;
              thisblock->next = thisblock->next->next;
            }
          return;
        }
      else if ((size_t) thisblock == (size_t) block + block->size)
        {
          if (MALLOC_DIRECTION < 0
              && thisblock->next
              && (size_t) block == ((size_t) thisblock->next 
                                    + thisblock->next->size))
            {
              *nextfree = thisblock->next;
              thisblock->next->size += block->size + thisblock->size;
            }
          else
            {
              block->size += thisblock->size;
              block->next = thisblock->next;
              *nextfree = block;
            }
          return;
        }
      else if ((MALLOC_DIRECTION > 0
                && (size_t) thisblock > (size_t) block)
               || (MALLOC_DIRECTION < 0
                   && (size_t) thisblock < (size_t) block))
        break;
    }

  block->next = *nextfree;
  *nextfree = block;
  return;
}
#endif

#ifdef DEFINE_REALLOC
void *
realloc (void *block_p, size_t sz)
{
  fle block = (fle)((size_t) block_p - offsetof (struct freelist_entry, next));
  size_t real_size = REAL_SIZE (sz);
  size_t old_real_size;

  if (block_p == NULL)
    return malloc (sz);

  old_real_size = block->size;

  /* Perhaps we need to allocate more space.  */
  if (old_real_size < real_size)
    {
      void *result;
      size_t old_size = old_real_size - sizeof (size_t);
      
      /* Need to allocate, copy, and free.  */
      result = malloc (sz);
      if (result == NULL)
        return NULL;
      memcpy (result, block_p, old_size < sz ? old_size : sz);
      free (block_p);
      return result;
    }
  /* Perhaps we can free some space.  */
  if (old_real_size - real_size >= sizeof (struct freelist_entry))
    {
      fle newblock = (fle)((size_t)block + real_size);
      block->size = real_size;
      newblock->size = old_real_size - real_size;
      free (&newblock->next);
    }
  return block_p;
}
#endif

#ifdef DEFINE_CALLOC
void *
calloc (size_t n, size_t elem_size)
{
  void *result;
  size_t sz = n * elem_size;
  result = malloc (sz);
  if (result != NULL)
    memset (result, 0, sz);
  return result;
}
#endif

#ifdef DEFINE_CFREE
void
cfree (void *p)
{
  free (p);
}
#endif

#ifdef DEFINE_MEMALIGN
void *
memalign (size_t align, size_t sz)
{
  fle *nextfree;
  fle block;

  /* real_size is the size we actually have to allocate, allowing for
     overhead and alignment.  */
  size_t real_size = REAL_SIZE (sz);

  /* Some sanity checking on 'align'. */
  if ((align & (align - 1)) != 0
      || align <= 0)
    return NULL;

  /* Look for the first block on the freelist that is large enough.  */
  /* One tricky part is this: We want the result to be a valid pointer
     to free.  That means that there has to be room for a size_t
     before the block.  If there's additional space before the block,
     it should go on the freelist, or it'll be lost---we could add it
     to the size of the block before it in memory, but finding the
     previous block is expensive.  */
  for (nextfree = &__malloc_freelist; 
       ; 
       nextfree = &(*nextfree)->next)  
    {
      size_t before_size;
      size_t old_size;

      /* If we've run out of free blocks, allocate more space.  */
      if (! *nextfree)
        {
          old_size = real_size;
          if (MALLOC_DIRECTION < 0)
            {
              old_size += M_ALIGN_SUB (((size_t)__malloc_end 
                                        - old_size + sizeof (size_t)),
                                       align);
              if (! CAN_ALLOC_P (old_size))
                return NULL;
              block = __malloc_end = (void *)((size_t)__malloc_end - old_size);
            }
          else
            {
              block = __malloc_end;
              old_size += M_ALIGN ((size_t)__malloc_end + sizeof (size_t),
                                   align);
              if (! CAN_ALLOC_P (old_size))
                return NULL;
              __malloc_end = (void *)((size_t)__malloc_end + old_size);
            }
          *nextfree = block;
          block->size = old_size;
          block->next = NULL;
        }
      else
        {
          block = *nextfree;
          old_size = block->size;
        }
      

      before_size = M_ALIGN (&block->next, align);
      if (before_size != 0)
        before_size = sizeof (*block) + M_ALIGN (&(block+1)->next, align);

      /* If this is the last block on the freelist, and it is too small,
         enlarge it.  */
      if (! block->next
          && old_size < real_size + before_size
          && __malloc_end == (void *)((size_t)block + block->size))
        {
          if (MALLOC_DIRECTION < 0)
            {
              size_t moresize = real_size - block->size;
              moresize += M_ALIGN_SUB ((size_t)&block->next - moresize, align);
              if (! CAN_ALLOC_P (moresize))
                return NULL;
              block = __malloc_end = (void *)((size_t)block - moresize);
              block->next = NULL;
              block->size = old_size = old_size + moresize;
              before_size = 0;
            }
          else
            {
              if (! CAN_ALLOC_P (before_size + real_size - block->size))
                return NULL;
              __malloc_end = (void *)((size_t)block + before_size + real_size);
              block->size = old_size = before_size + real_size;
            }

          /* Two out of the four cases below will now be possible; which
             two depends on MALLOC_DIRECTION.  */
        }

      if (old_size >= real_size + before_size)
        {
          /* This block will do.  If there needs to be space before it, 
             split the block.  */
          if (before_size != 0)
            {
              fle old_block = block;

              old_block->size = before_size;
              block = (fle)((size_t)block + before_size);
              
              /* If there's no space after the block, we're now nearly
                 done; just make a note of the size required.  
                 Otherwise, we need to create a new free space block.  */
              if (old_size - before_size 
                  <= real_size + sizeof (struct freelist_entry))
                {
                  block->size = old_size - before_size;
                  return (void *)&block->next;
                }
              else 
                {
                  fle new_block;
                  new_block = (fle)((size_t)block + real_size);
                  new_block->size = old_size - before_size - real_size;
                  if (MALLOC_DIRECTION > 0)
                    {
                      new_block->next = old_block->next;
                      old_block->next = new_block;
                    }
                  else
                    {
                      new_block->next = old_block;
                      *nextfree = new_block;
                    }
                  goto done;
                }
            }
          else
            {
              /* If the block found is just the right size, remove it from
                 the free list.  Otherwise, split it.  */
              if (old_size <= real_size + sizeof (struct freelist_entry))
                {
                  *nextfree = block->next;
                  return (void *)&block->next;
                }
              else
                {
                  size_t newsize = old_size - real_size;
                  fle newnext = block->next;
                  *nextfree = (fle)((size_t)block + real_size);
                  (*nextfree)->size = newsize;
                  (*nextfree)->next = newnext;
                  goto done;
                }
            }
        }
    }

 done:
  block->size = real_size;
  return (void *)&block->next;
}
#endif

#ifdef DEFINE_VALLOC
void *
valloc (size_t sz)
{
  return memalign (128, sz);
}
#endif
#ifdef DEFINE_PVALLOC
void *
pvalloc (size_t sz)
{
  return memalign (128, sz + M_ALIGN (sz, 128));
}
#endif

#ifdef DEFINE_MALLINFO
#include "malloc.h"

struct mallinfo 
mallinfo (void)
{
  struct mallinfo r;
  fle fr;
  size_t free_size;
  size_t total_size;
  size_t free_blocks;

  memset (&r, 0, sizeof (r));

  free_size = 0;
  free_blocks = 0;
  for (fr = __malloc_freelist; fr; fr = fr->next)
    {
      free_size += fr->size;
      free_blocks++;
      if (! fr->next)
        {
          int atend;
          if (MALLOC_DIRECTION > 0)
            atend = (void *)((size_t)fr + fr->size) == __malloc_end;
          else
            atend = (void *)fr == __malloc_end;
          if (atend)
            r.keepcost = fr->size;
        }
    }

  if (MALLOC_DIRECTION > 0)
    total_size = (char *)__malloc_end - (char *)&__malloc_start;
  else
    total_size = (char *)&__malloc_start - (char *)__malloc_end;
  
#ifdef DEBUG
  /* Fixme: should walk through all the in-use blocks and see if
     they're valid.  */
#endif

  r.arena = total_size;
  r.fordblks = free_size;
  r.uordblks = total_size - free_size;
  r.ordblks = free_blocks;
  return r;
}
#endif

#ifdef DEFINE_MALLOC_STATS
#include "malloc.h"
#include <stdio.h>

void 
malloc_stats(void)
{
  struct mallinfo i;
  FILE *fp;
  
  fp = stderr;
  i = mallinfo();
  fprintf (fp, "malloc has reserved %u bytes between %p and %p\n",
           i.arena, &__malloc_start, __malloc_end);
  fprintf (fp, "there are %u bytes free in %u chunks\n",
           i.fordblks, i.ordblks);
  fprintf (fp, "of which %u bytes are at the end of the reserved space\n",
           i.keepcost);
  fprintf (fp, "and %u bytes are in use.\n", i.uordblks);
}
#endif

#ifdef DEFINE_MALLOC_USABLE_SIZE
size_t 
malloc_usable_size (void *block_p)
{
  fle block = (fle)((size_t) block_p - offsetof (struct freelist_entry, next));
  return block->size - sizeof (size_t);
}
#endif

#ifdef DEFINE_MALLOPT
int
mallopt (int n, int v)
{
  (void)n; (void)v;
  return 0;
}
#endif