src/free_atexit.c

   1 /*                            COPYRIGHT
   2  *
   3  *  Copyright (C) 2010 PCB Contributors (see ChangeLog for details)
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *
  19  *  Contact addresses for paper mail and Email:
  20  *  harry eaton, 6697 Buttonhole Ct, Columbia, MD 21044 USA
  21  *  haceaton@aplcomm.jhuapl.edu
  22  *
  23  */
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 /* we need one ID per context - short int with 64k IDs should be enough */
  29 typedef unsigned int leaky_idx_t;
  30
  31
  32 /* This structure should be as big as void *, which should be the natural
  33 bit-width of the architecture. We allocate extra admin space to be as big
  34 as this union, to preserve alignment of pointers returned by malloc().
  35 NOTE: in the special corner case when leaky_idx_t is wider than void * but
  36 not multiple of it, the alignment will be messed up, potentially causing slower
  37 memory access. */
  38 typedef union {
  39   leaky_idx_t idx;
  40   void *ptr;
  41 } leaky_admin_t;
  42
  43 static void         **free_list = NULL;
  44 static leaky_idx_t  free_size = 0;
  45
  46
  47 void *leaky_malloc (size_t size)
  48 {
  49   void *new_memory = malloc(size + sizeof(leaky_admin_t));
  50
  51   free_list = (void **)realloc (free_list, (free_size + 1) * sizeof(void *));
  52   free_list[free_size] = new_memory;
  53   *(leaky_idx_t *)new_memory = free_size;
  54
  55   free_size++;
  56   return new_memory + sizeof(leaky_admin_t);
  57 }
  58
  59 void *leaky_calloc (size_t nmemb, size_t size)
  60 {
  61   size_t size_ = size * nmemb;
  62   void *new_memory = leaky_malloc (size_);
  63
  64   memset (new_memory, 0, size_);
  65   return new_memory;
  66 }
  67
  68 void *leaky_realloc (void* old_memory, size_t size)
  69 {
  70   void *new_memory;
  71   leaky_idx_t i;
  72
  73   if (old_memory == NULL)
  74     return leaky_malloc (size);
  75
  76   old_memory -= sizeof(leaky_admin_t);
  77
  78   i = *(leaky_idx_t *)old_memory;
  79
  80   new_memory = realloc (old_memory, size + sizeof(leaky_admin_t));
  81   free_list[i] = new_memory;
  82
  83   return new_memory + sizeof(leaky_admin_t);
  84 }
  85
  86 void leaky_uninit (void)
  87 {
  88   int i;
  89
  90   for (i = 0; i < free_size; i++)
  91     free (free_list[i]);
  92
  93   free (free_list);
  94   free_size = 0;
  95 }
  96
  97 void leaky_init (void)
  98 {
  99   atexit(leaky_uninit);
 100 }