workbench/libs/expat/malloc.c

   1 /* Copyright 2007-2012 Fredrik Wikstrom. All rights reserved.
   2 **
   3 ** Redistribution and use in source and binary forms, with or without
   4 ** modification, are permitted provided that the following conditions
   5 ** are met:
   6 **
   7 ** 1. Redistributions of source code must retain the above copyright
   8 **    notice, this list of conditions and the following disclaimer.
   9 **
  10 ** 2. Redistributions in binary form must reproduce the above copyright
  11 **    notice, this list of conditions and the following disclaimer in the
  12 **    documentation and/or other materials provided with the distribution.
  13 **
  14 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  15 ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17 ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  18 ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  19 ** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  20 ** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  21 ** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  22 ** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  23 ** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  24 ** POSSIBILITY OF SUCH DAMAGE.
  25 */
  26
  27 #include <proto/exec.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include "support.h"
  31
  32 #define MIN(a,b) ((a)<=(b)?(a):(b))
  33 #define BASE_PTR(ptr) ((APTR)((size_t *)ptr - 1))
  34 #define ALLOC_SIZE(ptr) (*((size_t *)ptr - 1))
  35
  36 static struct SignalSemaphore *LibPoolSemaphore;
  37 static APTR LibPool;
  38
  39 int malloc_init(void) {
  40         LibPoolSemaphore = CreateSemaphore();
  41         if (LibPoolSemaphore) {
  42                 LibPool = CreatePool(MEMF_ANY, 4096, 1024);
  43                 if (LibPool) {
  44                         return TRUE;
  45                 }
  46                 DeleteSemaphore(LibPoolSemaphore);
  47         }
  48         return FALSE;
  49 }
  50
  51 void malloc_exit(void) {
  52         DeletePool(LibPool);
  53         DeleteSemaphore(LibPoolSemaphore);
  54 }
  55
  56 APTR malloc(size_t size) {
  57         size_t *ptr;
  58         ObtainSemaphore(LibPoolSemaphore);
  59         ptr = AllocPooled(LibPool, sizeof(size_t) + size);
  60         ReleaseSemaphore(LibPoolSemaphore);
  61         if (ptr) {
  62                 *ptr++ = size;
  63         }
  64         return ptr;
  65 }
  66
  67 APTR realloc(APTR old, size_t size) {
  68         if (old) {
  69                 size_t old_size = ALLOC_SIZE(old);
  70                 APTR new;
  71                 if (size == old_size) {
  72                         return old;
  73                 }
  74                 new = malloc(size);
  75                 if (new) {
  76                         memcpy(new, old, MIN(size, old_size));
  77                         free(old);
  78                         return new;
  79                 }
  80                 free(old);
  81                 return NULL;
  82         } else {
  83                 return malloc(size);
  84         }
  85 }
  86
  87 void free(APTR ptr) {
  88         if (ptr) {
  89                 ObtainSemaphore(LibPoolSemaphore);
  90                 FreePooled(LibPool, BASE_PTR(ptr), sizeof(size_t) + ALLOC_SIZE(ptr));
  91                 ReleaseSemaphore(LibPoolSemaphore);
  92         }
  93 }