cc65/libsrc/common/_aligned_malloc.c

/*****************************************************************************/
/*                                                                           */
/*                              _aligned_malloc                              */
/*                                                                           */
/*                     Allocate an aligned memory block                      */
/*                                                                           */
/*                                                                           */
/*                                                                           */
/* (C) 2004-2005 Ullrich von Bassewitz                                       */
/*               Römerstrasse 52                                             */
/*               D-70794 Filderstadt                                         */
/* EMail:        uz@cc65.org                                                 */
/*                                                                           */
/*                                                                           */
/* This software is provided 'as-is', without any expressed or implied       */
/* warranty.  In no event will the authors be held liable for any damages    */
/* arising from the use of this software.                                    */
/*                                                                           */
/* Permission is granted to anyone to use this software for any purpose,     */
/* including commercial applications, and to alter it and redistribute it    */
/* freely, subject to the following restrictions:                            */
/*                                                                           */
/* 1. The origin of this software must not be misrepresented; you must not   */
/*    claim that you wrote the original software. If you use this software   */
/*    in a product, an acknowledgment in the product documentation would be  */
/*    appreciated but is not required.                                       */
/* 2. Altered source versions must be plainly marked as such, and must not   */
/*    be misrepresented as being the original software.                      */
/* 3. This notice may not be removed or altered from any source              */
/*    distribution.                                                          */
/*                                                                           */
/*****************************************************************************/



#include <stdlib.h>
#include <_heap.h>



/* This is a very simple version of an aligned memory allocator. We will
 * allocate a greater block, so we can place the aligned block within it
 * that is returned. We use our knowledge about the internal heap
 * structures to free the unused parts of the bigger block (the two chunks
 * below and above the aligned block).
 */



void* __fastcall__ _aligned_malloc (size_t size, size_t alignment)
/* Allocate a block of memory with the given size, which is aligned to a
 * memory address that is a multiple of alignment. alignment MUST NOT be
 * zero and MUST be a power of two, otherwise a call to this function will 
 * cause undefined behaviour. The function returns NULL if not enough memory 
 * is available to satisfy the request. To free the allocated block, use the
 * free() function.
 */
{
    size_t rawsize;
    size_t uppersize;
    size_t lowersize;
    register struct usedblock* b;
    register struct usedblock* u;
    register struct usedblock* p;

    /* Handle requests for zero sized blocks */
    if (size == 0) {
        return 0;
    }

    /* We don't really need alignment, but alignment-1 */
    --alignment;

    /* Round up the block size and allocate memory. We don't need to account
     * for the additional admin data needed to manage the used block, since
     * the block returned by malloc has this overhead added one time, and
     * the worst thing that may happen is that we cannot free the upper and
     * lower blocks.
     */
    b = malloc (size + alignment);

    /* Handle out of memory */
    if (b == 0) {
        return 0;
    }

    /* Create a new pointer that points to the user visible aligned block. */
    u = (struct usedblock*) (((unsigned)b + alignment) & ~alignment);

    /* Get the raw block pointer, which is located just below the user visible
     * block. The first word of this raw block is the total size of the block
     * including the admin space.
     */
    b = (b-1)->start;
    rawsize = b->size;

    /* Get a pointer to the (raw) upper block */
    p = (struct usedblock*) (size + (unsigned)u);

    /* Check if we can free the space above the allocated block. This is the
     * case if the size of the block is at least sizeof (struct freeblock)
     * bytes and the size of the remaining block is at least of this size,
     * too. If the upper block is smaller, we will just pass it to the caller
     * together with the requested aligned block.
     */
    uppersize = rawsize + (unsigned)b - (unsigned)p;
    if (uppersize >= sizeof (struct freeblock) &&
        (rawsize - uppersize) >= sizeof (struct freeblock)) {

        /* Setup the usedblock structure */
        p->size  = uppersize;
        p->start = p;

        /* Generate a pointer to the user space and free the block */
        free (p + 1);

        /* Decrement the raw block size by the amount of space just free'd */
        rawsize -= uppersize;
    }

    /* Check if we can free the space below the allocated block. This is the
     * case, if the size of the block is at least sizeof (struct freeblock)
     * bytes and the size of the remaining block is at least of this size,
     * too. If the lower block is smaller, we will just pass it to the caller
     * together with the requested aligned block.
     * Beware: We need an additional struct usedblock in the lower block which
     * is part of the block that is passed back to the caller.
     */
    lowersize = ((unsigned)u - (unsigned)b) - sizeof (struct usedblock);
    if (lowersize >= sizeof (struct freeblock) &&
        (rawsize - lowersize) >= sizeof (struct freeblock)) {

        /* b does already point to the raw lower block. Setup the usedblock
         * structure.
         */
        b->size  = lowersize;
        b->start = b;

        /* Generate a pointer to the user space and free the block */
        free (b + 1);

        /* Decrement the raw block size by the amount of space just free'd */
        rawsize -= lowersize;

        /* Set b to the raw user block */
        b = u - 1;
    }

    /* u does now point to the user visible block, while b points to the raw
     * block, and rawsize contains the size of the raw block. Setup the
     * usedblock structure but beware: If we didn't free the lower block, it
     * is splitted, which means that we must use u to write the start field,
     * and b to write the size.
     */
    (u-1)->start = b;
    b->size  = rawsize;

    /* Return the user portion of the aligned block */
    return u;
}