compiler/purify/src/memory.c

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