libc/stdlib/malloc-standard/memalign.c

   1 /*
   2   This is a version (aka dlmalloc) of malloc/free/realloc written by
   3   Doug Lea and released to the public domain.  Use, modify, and
   4   redistribute this code without permission or acknowledgement in any
   5   way you wish.  Send questions, comments, complaints, performance
   6   data, etc to dl@cs.oswego.edu
   7
   8   VERSION 2.7.2 Sat Aug 17 09:07:30 2002  Doug Lea  (dl at gee)
   9
  10   Note: There may be an updated version of this malloc obtainable at
  11            ftp://gee.cs.oswego.edu/pub/misc/malloc.c
  12   Check before installing!
  13
  14   Hacked up for uClibc by Erik Andersen <andersen@codepoet.org>
  15 */
  16
  17 #include <features.h>
  18 #include <stddef.h>
  19 #include <unistd.h>
  20 #include <errno.h>
  21 #include <string.h>
  22 #include "malloc.h"
  23
  24
  25 /* ------------------------------ memalign ------------------------------ */
  26 void* memalign(size_t alignment, size_t bytes)
  27 {
  28     size_t nb;             /* padded  request size */
  29     char*           m;              /* memory returned by malloc call */
  30     mchunkptr       p;              /* corresponding chunk */
  31     char*           _brk;            /* alignment point within p */
  32     mchunkptr       newp;           /* chunk to return */
  33     size_t newsize;        /* its size */
  34     size_t leadsize;       /* leading space before alignment point */
  35     mchunkptr       remainder;      /* spare room at end to split off */
  36     unsigned long    remainder_size; /* its size */
  37     size_t size;
  38     void *retval;
  39
  40     /* If need less alignment than we give anyway, just relay to malloc */
  41
  42     if (alignment <= MALLOC_ALIGNMENT) return malloc(bytes);
  43
  44     /* Otherwise, ensure that it is at least a minimum chunk size */
  45
  46     if (alignment <  MINSIZE) alignment = MINSIZE;
  47
  48     /* Make sure alignment is power of 2 (in case MINSIZE is not).  */
  49     if ((alignment & (alignment - 1)) != 0) {
  50         size_t a = MALLOC_ALIGNMENT * 2;
  51         while ((unsigned long)a < (unsigned long)alignment) a <<= 1;
  52         alignment = a;
  53     }
  54
  55     checked_request2size(bytes, nb);
  56     __MALLOC_LOCK;
  57
  58     /* Strategy: find a spot within that chunk that meets the alignment
  59      * request, and then possibly free the leading and trailing space.  */
  60
  61
  62     /* Call malloc with worst case padding to hit alignment. */
  63
  64     m  = (char*)(malloc(nb + alignment + MINSIZE));
  65
  66     if (m == 0) {
  67         retval = 0; /* propagate failure */
  68         goto DONE;
  69     }
  70
  71     p = mem2chunk(m);
  72
  73     if ((((unsigned long)(m)) % alignment) != 0) { /* misaligned */
  74
  75         /*
  76            Find an aligned spot inside chunk.  Since we need to give back
  77            leading space in a chunk of at least MINSIZE, if the first
  78            calculation places us at a spot with less than MINSIZE leader,
  79            we can move to the next aligned spot -- we've allocated enough
  80            total room so that this is always possible.
  81            */
  82
  83         _brk = (char*)mem2chunk((unsigned long)(((unsigned long)(m + alignment - 1)) &
  84                     -((signed long) alignment)));
  85         if ((unsigned long)(_brk - (char*)(p)) < MINSIZE)
  86             _brk += alignment;
  87
  88         newp = (mchunkptr)_brk;
  89         leadsize = _brk - (char*)(p);
  90         newsize = chunksize(p) - leadsize;
  91
  92         /* For mmapped chunks, just adjust offset */
  93         if (chunk_is_mmapped(p)) {
  94             newp->prev_size = p->prev_size + leadsize;
  95             set_head(newp, newsize|IS_MMAPPED);
  96             retval = chunk2mem(newp);
  97             goto DONE;
  98         }
  99
 100         /* Otherwise, give back leader, use the rest */
 101         set_head(newp, newsize | PREV_INUSE);
 102         set_inuse_bit_at_offset(newp, newsize);
 103         set_head_size(p, leadsize);
 104         free(chunk2mem(p));
 105         p = newp;
 106
 107         assert (newsize >= nb &&
 108                 (((unsigned long)(chunk2mem(p))) % alignment) == 0);
 109     }
 110
 111     /* Also give back spare room at the end */
 112     if (!chunk_is_mmapped(p)) {
 113         size = chunksize(p);
 114         if ((unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
 115             remainder_size = size - nb;
 116             remainder = chunk_at_offset(p, nb);
 117             set_head(remainder, remainder_size | PREV_INUSE);
 118             set_head_size(p, nb);
 119             free(chunk2mem(remainder));
 120         }
 121     }
 122
 123     check_inuse_chunk(p);
 124     retval = chunk2mem(p);
 125
 126  DONE:
 127     __MALLOC_UNLOCK;
 128         return retval;
 129 }
 130 weak_alias(memalign, aligned_alloc)
 131 libc_hidden_def(memalign)
 132 /* glibc compatibilty  */
 133 weak_alias(memalign, __libc_memalign)