/* xxxx my own */
mchunkptr sanity_check(void* mem)
{
mchunkptr p = (mchunkptr)((char*)(mem) - SIZE_SZ);
/* a quick sanity check */
unsigned int sz = p->size & ~(INUSE);
if (p->size == sz || sz != *((int*)((char*)(p) + sz - SIZE_SZ)))
malloc_user_error();
return p;
}
static inline mchunkptr mem2chunk(void* mem)
{
mchunkptr p = (mchunkptr)((char*)(mem) - SIZE_SZ);
/* a quick sanity check */
size_t sz = p->size & ~(INUSE);
if (p->size == sz || sz != *((int*)((char*)(p) + sz - SIZE_SZ)))
malloc_user_error();
p->size = sz; /* clears INUSE */
return p;
}
void* memalign(size_t alignment, size_t bytes)
{
mchunkptr p;
size_t nb = request2size(bytes);
/* find an alignment that both we and the user can live with: */
/* least common multiple guarantees mutual happiness */
size_t align = lcm(alignment, MALLOC_MIN_OVERHEAD);
size_t mask = align - 1;
/* call malloc with worst case padding to hit alignment; */
/* we will give back extra */
size_t req = nb + align + MINSIZE;
void* m = malloc(req);
if (m == 0) return m;
p = mem2chunk(m);
/* keep statistics on track */
UPDATE_STATS(--n_mallocs);
UPDATE_STATS(malloced_mem -= p->size);
UPDATE_STATS(requested_mem -= req);
UPDATE_STATS(requested_mem += bytes);
if (((int)(m) & (mask)) != 0) /* misaligned */
{
/* find an aligned spot inside chunk */
mchunkptr ap = (mchunkptr)(( ((int)(m) + mask) & -align) - SIZE_SZ);
size_t gap = (size_t )(ap) - (size_t )(p);
size_t room;
/* we need to give back leading space in a chunk of at least MINSIZE */
if (gap < MINSIZE)
{
/* This works since align >= MINSIZE */
/* and we've malloc'd enough total room */
ap = (mchunkptr)( (int)(ap) + align );
gap += align;
}
if (gap + nb > p->size) /* can't happen unless chunk sizes corrupted */
malloc_user_error();
room = p->size - gap;
/* give back leader */
set_size(p, gap);
consollink(p);
/* use the rest */
p = ap;
set_size(p, room);
}
/* also give back spare room at the end */
split(p, nb);
UPDATE_STATS(do_malloc_stats(p));
return chunk2mem(p);
}
