compiler/purify/src/hash.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <stdio.h>
   7 #include <assert.h>
   8 #include <limits.h>
   9 #include "hash.h"
  10 #include "util.h"
  11 #include "error.h"
  12 #include "memory.h"
  13 #include "debug.h"
  14
  15 MemHashTable memHash;
  16 MemHash * Purify_LastNode;
  17
  18 #define CalcHash(addr) \
  19     ({ unsigned long x; \
  20         x = (long)(addr); \
  21         x >>= 16; \
  22         ((x & 0xFF) ^ (x >> 8)) & 0xFF; \
  23     })
  24
  25 MemHash * Purify_AddMemory (void * memory, int size, int flag, int type)
  26 {
  27     MemHash * node = xmalloc (sizeof (MemHash));
  28     int hashcode;
  29
  30     node->mem   = memory;
  31     node->flags = xmalloc (size);
  32     node->size  = size;
  33     node->type  = type;
  34     node->data  = NULL;
  35
  36     if (flag != -1)
  37         Purify_SetMemoryFlags (node, 0, size, flag);
  38
  39     hashcode = CalcHash (memory);
  40
  41     node->next = memHash[hashcode];
  42     memHash[hashcode] = node;
  43
  44     return node;
  45 }
  46
  47 void Purify_RemMemory (const void * mem)
  48 {
  49     int hashcode = CalcHash (mem);
  50     MemHash * node = (MemHash *)&memHash[hashcode], * next;
  51
  52 #if LDEBUG
  53     printf ("Purify_FindMemory (mem=%p)\n", mem);
  54 #endif
  55
  56     for ( ; (next=node->next); node=next)
  57     {
  58 #if LDEBUG
  59         printf ("    Checking against %p:%d (%p)\n",
  60             node->mem, node->size, node->mem+node->size);
  61 #endif
  62         if (next->mem <= mem && next->mem+next->size > mem)
  63         {
  64 #if LDEBUG
  65             printf ("    Node found\n");
  66 #endif
  67             node->next = next->next;
  68             xfree (next);
  69             if (Purify_LastNode == next)
  70                 Purify_LastNode = NULL;
  71             return;
  72         }
  73     }
  74
  75 #if LDEBUG
  76     printf ("    Nothing found\n");
  77 #endif
  78 }
  79
  80
  81 void Purify_SetMemoryFlags (MemHash * mem, int offset, int size, int flag)
  82 {
  83     char * ptr;
  84
  85 #if 0
  86     printf ("SetMemoryFlags (hash=%p, offset=%d, size=%d, flag=%d)\n",
  87         mem, offset, size, flag
  88     );
  89 #endif
  90
  91     passert (offset+size <= mem->size);
  92
  93     ptr = mem->flags + offset;
  94
  95     while (size--)
  96         *ptr ++ = flag;
  97 }
  98
  99 void Purify_ModifyMemoryFlags (MemHash * mem, int offset, int size, int flag,
 100     int mask)
 101 {
 102     char * ptr;
 103
 104     passert (offset+size <= mem->size);
 105
 106     ptr = mem->flags + offset;
 107
 108     flag &= mask;
 109     mask = ~mask;
 110
 111     while (size--)
 112     {
 113         *ptr = (*ptr & mask) | flag;
 114         ptr ++;
 115     }
 116 }
 117
 118 #undef LDEBUG
 119 #define LDEBUG 0
 120
 121 MemHash * Purify_FindMemory (const void * mem)
 122 {
 123     int hashcode = CalcHash (mem);
 124     MemHash * node = memHash[hashcode];
 125
 126 #if LDEBUG
 127     printf ("Purify_FindMemory (mem=%p)\n", mem);
 128 #endif
 129
 130     for ( ; node; node=node->next)
 131     {
 132 #if LDEBUG
 133         printf ("    Checking against %p:%d (%p)\n",
 134             node->mem, node->size, node->mem+node->size);
 135 #endif
 136         if (node->mem <= mem && node->mem+node->size > mem)
 137         {
 138             Purify_LastNode = node;
 139 #if LDEBUG
 140             printf ("    Node found\n");
 141 #endif
 142             return node;
 143         }
 144     }
 145
 146     Purify_LastNode = NULL;
 147     Purify_Error = NotOwnMemory;
 148
 149 #if LDEBUG
 150     printf ("    Nothing found\n");
 151 #endif
 152     return NULL;
 153 }
 154
 155 int Purify_CheckMemoryAccess (const void * mem, int size, int access)
 156 {
 157     MemHash * node = Purify_FindMemory (mem);
 158     long offset, cnt;
 159     char * ptr;
 160
 161     if (!node)
 162         return 0;
 163
 164     offset = (long)mem - (long)node->mem;
 165
 166     if (offset+size > node->size)
 167     {
 168         Purify_Error = BorderAccess;
 169         return 0;
 170     }
 171
 172     ptr = node->flags + offset;
 173
 174     if (access == PURIFY_MemAccess_Read)
 175     {
 176         cnt = size;
 177         while (cnt--)
 178         {
 179             if (!(*ptr & PURIFY_MemFlag_Readable) )
 180             {
 181                 if (*ptr & PURIFY_MemFlag_Free)
 182                 {
 183                     Purify_Error = (node->type == PURIFY_MemType_Stack)
 184                         ? FreeStackRead : FreeRead;
 185                     return 0;
 186                 }
 187                 else if (*ptr & PURIFY_MemFlag_Empty)
 188                 {
 189                     Purify_Error = UndefRead;
 190                     return 0;
 191                 }
 192                 else
 193                 {
 194                     Purify_Error = IllRead;
 195                     return 0;
 196                 }
 197             }
 198
 199             ptr ++;
 200         }
 201     }
 202     else /* write */
 203     {
 204         if (node->type == PURIFY_MemType_Code)
 205         {
 206             Purify_Error = CodeWrite;
 207             return 0;
 208         }
 209
 210         cnt=size;
 211         while (cnt--)
 212         {
 213             if (!(*ptr & PURIFY_MemFlag_Writable) )
 214             {
 215                 if (*ptr & PURIFY_MemFlag_Free)
 216                 {
 217                     Purify_Error =
 218                         (node->type == PURIFY_MemType_Stack)
 219                             ? FreeStackWrite
 220                             : FreeWrite;
 221                     return 0;
 222                 }
 223                 else
 224                 {
 225                     Purify_Error = IllWrite;
 226                     return 0;
 227                 }
 228             }
 229
 230             ptr ++;
 231         }
 232
 233         Purify_ModifyMemoryFlags (node, offset, size,
 234             PURIFY_MemFlag_Readable,
 235             PURIFY_MemFlag_Readable|PURIFY_MemFlag_Empty
 236         );
 237     }
 238
 239     return 1;
 240 }
 241
 242 void Purify_PrintMemory (void)
 243 {
 244     MemHash * node;
 245     int i;
 246 #if 0
 247     int t, cnt;
 248 #endif
 249
 250     for (i=0; i<256; i++)
 251     {
 252         if ((node = memHash[i]))
 253         {
 254             printf ("Hashline %3d:\n", i);
 255
 256             for ( ;
 257                 node;
 258                 node=node->next
 259             )
 260             {
 261                 printf ("    Node %p: Memory=%p Size=%d Type=",
 262                     node,
 263                     node->mem,
 264                     node->size
 265                 );
 266
 267                 switch (node->type)
 268                 {
 269                 case PURIFY_MemType_Heap:  printf ("heap "); break;
 270                 case PURIFY_MemType_Stack: printf ("stack"); break;
 271                 case PURIFY_MemType_Code:  printf ("code "); break;
 272                 case PURIFY_MemType_Data:  printf ("data "); break;
 273                 }
 274
 275                 if (node->data)
 276                 {
 277                     switch (node->type)
 278                     {
 279                     case PURIFY_MemType_Stack:
 280                     case PURIFY_MemType_Code:
 281                     case PURIFY_MemType_Data:
 282                         printf (" name=\"%s\"", (char *)node->data);
 283                         break;
 284
 285                     case PURIFY_MemType_Heap:
 286                         {
 287                             PMemoryNode * mem = (PMemoryNode *)(node->data);
 288
 289                             printf (" %s()", mem->alloc.current.functionname);
 290                         }
 291                         break;
 292                     }
 293                 }
 294
 295                 putchar ('\n');
 296
 297 #if 0
 298 #define WIDTH   56
 299
 300                 for (cnt=0,t=0; t<node->size; t++,cnt++)
 301                 {
 302                     if (cnt == 0)
 303                         printf ("\t%4d: ", t);
 304
 305                     printf ("%x", node->flags[t]);
 306
 307                     if (cnt == WIDTH-1)
 308                     {
 309                         putchar ('\n');
 310                         cnt = -1;
 311                     }
 312                     else if ((cnt & 7) == 7)
 313                         putchar (' ');
 314                 }
 315
 316                 if (((t-1) & WIDTH) != WIDTH-1)
 317                     putchar ('\n');
 318 #endif
 319             }
 320         }
 321     }
 322 }
 323
 324 #ifndef ABS
 325 #   define ABS(x)       (((x) < 0) ? -(x) : (x))
 326 #endif
 327
 328 MemHash * Purify_FindNextMemory (const void * mem, int * offsetptr)
 329 {
 330     MemHash * node, * next;
 331     int i, offset, o;
 332
 333     next = NULL;
 334     offset = INT_MAX;
 335
 336     for (i=0; i<256; i++)
 337     {
 338         for (node = memHash[i];
 339             node;
 340             node=node->next
 341         )
 342         {
 343             o = (long)mem - (long)node->mem;
 344
 345             if (o > 0)
 346             {
 347                 if (o < node->size)
 348                 {
 349                     *offsetptr = o;
 350                     return node;
 351                 }
 352                 else
 353                 {
 354                     o -= node->size;
 355                 }
 356             }
 357
 358             if (ABS(o) < ABS(offset)
 359                 || (ABS(o) == ABS(offset) && o > 0)
 360             )
 361             {
 362                 offset = o;
 363                 next = node;
 364             }
 365         }
 366     }
 367
 368     *offsetptr = offset;
 369     return next;
 370 }