compiler/purify/src/memory.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include "memory.h"
   5 #include "hash.h"
   6 #include "posinfo.h"
   7 #include "error.h"
   8 #include "util.h"
   9
  10 #define ALIGN(x)    (char *)((((long)(x))+15) & -8)
  11
  12 void * Purify_malloc (size_t size)
  13 {
  14     PMemoryNode * node = malloc (sizeof (PMemoryNode) + size);
  15     MemHash * hash;
  16
  17     if (!node)
  18         return NULL;
  19
  20     Purify_RememberCallers (&node->alloc);
  21
  22     node->free.nstack = -1; /* Not freed yet */
  23
  24     node->memptr = ALIGN(node->mem);
  25
  26     hash = Purify_AddMemory (node->memptr, size,
  27         PURIFY_MemFlag_Writable
  28         | PURIFY_MemFlag_Empty
  29         , PURIFY_MemType_Heap
  30     );
  31
  32     hash->data = node;
  33
  34     return node->memptr;
  35 }
  36
  37 void * Purify_calloc (size_t nemb, size_t size)
  38 {
  39     PMemoryNode * node = calloc (1, sizeof (PMemoryNode) + nemb*size);
  40     MemHash * hash;
  41
  42     if (!node)
  43         return NULL;
  44
  45     Purify_RememberCallers (&node->alloc);
  46
  47     node->free.nstack = -1; /* Not freed yet */
  48
  49     node->memptr = ALIGN(node->mem);
  50
  51     hash = Purify_AddMemory (node->memptr, nemb*size,
  52         PURIFY_MemFlag_Readable
  53         | PURIFY_MemFlag_Writable
  54         , PURIFY_MemType_Heap
  55     );
  56
  57     hash->data = node;
  58
  59     return node->memptr;
  60 }
  61
  62 void * Purify_realloc (void * mem, size_t size)
  63 {
  64     PMemoryNode * oldnode, * newnode;
  65     MemHash * oldmem, * newmem;
  66
  67     if (size)
  68     {
  69         newnode = malloc (sizeof (PMemoryNode) + size);
  70
  71         if (!newnode)
  72             return NULL;
  73
  74         Purify_RememberCallers (&newnode->alloc);
  75
  76         newnode->free.nstack = -1; /* Not freed yet */
  77
  78         newnode->memptr = ALIGN(newnode->mem);
  79
  80         newmem = Purify_AddMemory (newnode->memptr, size,
  81             PURIFY_MemFlag_Writable
  82             | PURIFY_MemFlag_Empty
  83             , PURIFY_MemType_Heap
  84         );
  85
  86         newmem->data = newnode;
  87     }
  88     else
  89         newnode = NULL;
  90
  91     if (mem && size)
  92     {
  93         memcpy (newnode->memptr, mem, size);
  94     }
  95
  96     if (mem)
  97     {
  98         oldmem = Purify_FindMemory (mem);
  99
 100         if (!oldmem)
 101         {
 102             Purify_Error = IllPointer;
 103             Purify_PrintError ("realloc(addr=%p, size=%ld)", mem, size);
 104         }
 105         else
 106         {
 107             oldnode = (PMemoryNode *)(oldmem->data);
 108
 109             if (newnode)
 110             {
 111                 if (size > oldmem->size)
 112                     size = oldmem->size;
 113
 114                 memcpy (newnode->memptr, oldnode->memptr, size);
 115
 116                 Purify_SetMemoryFlags (newmem, 0, size,
 117                     PURIFY_MemFlag_Readable | PURIFY_MemFlag_Writable
 118                 );
 119             }
 120
 121             Purify_SetMemoryFlags (oldmem, 0, oldmem->size, PURIFY_MemFlag_Free);
 122             Purify_RememberCallers (&oldnode->free);
 123         }
 124     }
 125
 126     return newnode ? newnode->memptr : NULL;
 127 }
 128
 129 void Purify_free (void * mem)
 130 {
 131     MemHash * hash = Purify_FindMemory (mem);
 132     PMemoryNode * node;
 133
 134     if (!hash)
 135     {
 136         Purify_Error = IllPointer;
 137         Purify_PrintError ("free(addr=%p)", mem);
 138     }
 139     else
 140     {
 141         node = (PMemoryNode *)(hash->data);
 142
 143         Purify_SetMemoryFlags (hash, 0, hash->size, PURIFY_MemFlag_Free);
 144         Purify_RememberCallers (&node->free);
 145     }
 146 }
 147
 148 void Purify_MemoryExit (void)
 149 {
 150     extern MemHashTable memHash;
 151     MemHash * node;
 152     PMemoryNode * memnode;
 153     int i;
 154
 155     Purify_Error = MemLeak;
 156
 157     for (i=0; i<256; i++)
 158     {
 159         for (node=memHash[i];
 160             node;
 161             node=node->next
 162         )
 163         {
 164             if (node->type == PURIFY_MemType_Heap)
 165             {
 166                 memnode = (PMemoryNode *)(node->data);
 167
 168                 if (memnode->free.nstack == -1)
 169                 {
 170                     Purify_PrePrintError ();
 171                     fprintf (stderr,
 172                         "The memory block at %p with the size %d was allocated at\n",
 173                         node->mem, node->size
 174                     );
 175                     Purify_PrintCallers (&memnode->alloc);
 176                     Purify_PostPrintError ();
 177                 }
 178             }
 179         }
 180     }
 181 }
 182
 183 void * Purify_memmove (void *dest, const void *src, size_t n)
 184 {
 185     if (!Purify_CheckMemoryAccess (src, n, PURIFY_MemAccess_Read))
 186         Purify_PrintAccessError ("memmove (src)", src, n);
 187     if (!Purify_CheckMemoryAccess (dest, n, PURIFY_MemAccess_Write))
 188         Purify_PrintAccessError ("memmove (dest)", dest, n);
 189
 190     return memmove (dest, src, n);
 191 }
 192
 193 void * Purify_memset (void *dest, int c, size_t n)
 194 {
 195     if (!Purify_CheckMemoryAccess (dest, n, PURIFY_MemAccess_Write))
 196         Purify_PrintAccessError ("memmove (dest)", dest, n);
 197
 198     return memset (dest, c, n);
 199 }
 200
 201 void * Purify_memcpy (void *dest, const void *src, size_t n)
 202 {
 203     if (!Purify_CheckMemoryAccess (src, n, PURIFY_MemAccess_Read))
 204         Purify_PrintAccessError ("memcpy (src)", src, n);
 205
 206     if (!Purify_CheckMemoryAccess (dest, n, PURIFY_MemAccess_Write))
 207         Purify_PrintAccessError ("memcpy (dest)", dest, n);
 208
 209     return memcpy (dest, src, n);
 210 }
 211
 212 char * Purify_strcpy (char *dest, const char *src)
 213 {
 214     int len;
 215
 216     if (!Purify_CheckMemoryAccess (src, 1, PURIFY_MemAccess_Read))
 217         Purify_PrintAccessError ("strcpy (src)", src, 1);
 218
 219     len = strlen (src)+1;
 220
 221     if (!Purify_CheckMemoryAccess (src, len, PURIFY_MemAccess_Read))
 222         Purify_PrintAccessError ("strcpy (src)", src, len);
 223
 224     if (!Purify_CheckMemoryAccess (dest, len, PURIFY_MemAccess_Write))
 225         Purify_PrintAccessError ("strcpy (dest)", dest, len);
 226
 227     return strcpy (dest, src);
 228 }
 229
 230 char * Purify_strcat (char *dest, const char *src)
 231 {
 232     int slen, dlen;
 233
 234     if (!Purify_CheckMemoryAccess (src, 1, PURIFY_MemAccess_Read))
 235         Purify_PrintAccessError ("strcat (src)", src, 1);
 236
 237     slen = strlen (src)+1;
 238
 239     if (!Purify_CheckMemoryAccess (src, slen, PURIFY_MemAccess_Read))
 240         Purify_PrintAccessError ("strcat (src)", src, slen);
 241
 242     if (!Purify_CheckMemoryAccess (src, 1, PURIFY_MemAccess_Read))
 243         Purify_PrintAccessError ("strcat (dest)", dest, 1);
 244
 245     dlen = strlen (dest);
 246
 247     if (!Purify_CheckMemoryAccess (dest+dlen, slen, PURIFY_MemAccess_Write))
 248         Purify_PrintAccessError ("strcat (dest)", dest+dlen, slen);
 249
 250     return strcpy (dest+dlen, src);
 251 }
 252
 253 char * Purify_strncpy (char *dest, const char *src, size_t n)
 254 {
 255     if (!Purify_CheckMemoryAccess (src, n, PURIFY_MemAccess_Read))
 256         Purify_PrintAccessError ("strncpy (src)", src, n);
 257
 258     if (!Purify_CheckMemoryAccess (dest, n, PURIFY_MemAccess_Write))
 259         Purify_PrintAccessError ("strncpy (dest)", dest, n);
 260
 261     return strncpy (dest, src, n);
 262 }
 263
 264 char * Purify_strdup (char * src)
 265 {
 266     PMemoryNode * node;
 267     MemHash * hash;
 268     int size;
 269
 270     if (!Purify_CheckMemoryAccess (src, 1, PURIFY_MemAccess_Read))
 271         Purify_PrintAccessError ("strdup (src)", src, 1);
 272
 273     size = strlen (src) + 1;
 274
 275     node = malloc (sizeof (PMemoryNode) + size);
 276
 277     if (!node)
 278         return NULL;
 279
 280     Purify_RememberCallers (&node->alloc);
 281
 282     node->free.nstack = -1; /* Not freed yet */
 283
 284     node->memptr = ALIGN(node->mem);
 285
 286     hash = Purify_AddMemory (node->memptr, size,
 287         PURIFY_MemFlag_Writable
 288         | PURIFY_MemFlag_Readable
 289         , PURIFY_MemType_Heap
 290     );
 291
 292     hash->data = node;
 293
 294     strcpy (node->memptr, src);
 295
 296     return node->memptr;
 297 }