toolkit/heap.c

   1 /*
   2  * Memory alllocation for the Wine Library toolkit
   3  *
   4  * Copyright (C) 1994 Miguel de Icaza
   5  *
   6  * All the memory management is being done by the libc malloc and friends.
   7  */
   8
   9 /* #ifndef __STDC__ */
  10 #include <malloc.h>
  11 #include <stdio.h>
  12 #include <string.h>
  13 /* #endif */
  14 #include "windows.h"
  15 #include "xmalloc.h"
  16
  17 #ifdef WINELIB16
  18
  19 /* Controls the blocks per handle table */
  20 #define MAXBLOCKS 1024
  21
  22 static char Copyright [] = "Copyright (C) 1994 Miguel de Icaza";
  23
  24 typedef struct handle_table {
  25     struct handle_table *next;
  26     void *blocks [MAXBLOCKS];
  27 } handle_table_t;
  28
  29 static handle_table_t handle_table;
  30
  31 static void **HEAP_GetFreeSlot (HANDLE *hNum)
  32 {
  33     handle_table_t *table, *last;
  34     int i, j;
  35
  36     for (table = &handle_table, j = 0; table; table = table->next, j++){
  37         for (i = 0; i < MAXBLOCKS; i++)
  38             if (!table->blocks [i])
  39                 goto AssignBlock;
  40         last = table;
  41     }
  42
  43     /* No free slots */
  44     last->next = xmalloc (sizeof (handle_table_t));
  45     table = last->next;
  46     memset (table, 0, sizeof (handle_table_t));
  47     i = 0;
  48
  49  AssignBlock:
  50     *hNum = j*MAXBLOCKS+i;
  51     return &table->blocks [i];
  52 }
  53
  54 static void HEAP_Handle_is_Zero ()
  55 {
  56     printf ("Warning: Handle is Zero, segmentation fault comming\n");
  57 }
  58
  59 static void **HEAP_FindSlot (HANDLE hNum)
  60 {
  61     handle_table_t *table = &handle_table;
  62     int i, j;
  63
  64     if (!hNum)
  65         HEAP_Handle_is_Zero ();
  66
  67     hNum--;
  68     for (j = hNum; j > MAXBLOCKS; j -= MAXBLOCKS){
  69         table = table->next;
  70         if (!table) return 0;
  71     }
  72     return &table->blocks [hNum%MAXBLOCKS];
  73 }
  74
  75 HANDLE LocalAlloc (WORD flags, WORD bytes)
  76 {
  77     void *m;
  78     void **slot;
  79     HANDLE hMem;
  80
  81     slot = HEAP_GetFreeSlot (&hMem);
  82     if (flags & LMEM_WINE_ALIGN)
  83         m = memalign (4, bytes);
  84     else
  85         m = malloc (bytes);
  86     if (m){
  87         *slot = m;
  88         if (flags & LMEM_ZEROINIT)
  89             bzero (m, bytes);
  90
  91 #ifdef DEBUG_HEAP
  92         printf ("Handle %d [%d] = %p\n", hMem+1, bytes, m);
  93 #endif
  94         return hMem+1;
  95     }
  96     return 0;
  97 }
  98
  99 WORD LocalCompact (WORD min_free)
 100 {
 101     return min_free;
 102 }
 103
 104 WORD LocalFlags (HANDLE hMem)
 105 {
 106     return 0;
 107 }
 108
 109 HANDLE LocalFree (HANDLE hMem)
 110 {
 111     void **m = HEAP_FindSlot (hMem);
 112
 113     free (*m);
 114     *m = 0;
 115     return 0;
 116 }
 117
 118 BOOL LocalInit (WORD segment, WORD start, WORD end)
 119 {
 120     return 1;
 121 }
 122
 123 WORD LocalLock (HANDLE hMem)
 124 {
 125     void **m = HEAP_FindSlot (hMem);
 126 #ifdef DEBUG_HEAP
 127     printf (">%d->%p\n", hMem, *m);
 128 #endif
 129     return m ? *m : 0;
 130 }
 131
 132 HANDLE LocalReAlloc (HANDLE hMem, WORD flags, WORD bytes)
 133 {
 134     void **m = HEAP_FindSlot (hMem);
 135
 136     xrealloc (*m, bytes);
 137 }
 138
 139 WORD LocalSize (HANDLE hMem)
 140 {
 141     /* Not implemented yet */
 142 }
 143
 144
 145 BOOL LocalUnlock (HANDLE hMem)
 146 {
 147     return 0;
 148 }
 149
 150 HANDLE GlobalAlloc (WORD flags, DWORD size)
 151 {
 152     return LocalAlloc (flags, size);
 153 }
 154
 155 HANDLE GlobalFree (HANDLE hMem)
 156 {
 157     return LocalFree (hMem);
 158 }
 159
 160 char *GlobalLock (HANDLE hMem)
 161 {
 162     return LocalLock (hMem);
 163 }
 164
 165 BOOL GlobalUnlock (HANDLE hMem)
 166 {
 167     return LocalUnlock (hMem);
 168 }
 169
 170 WORD GlobalFlags (HANDLE hMem)
 171 {
 172     return LocalFlags (hMem);
 173 }
 174
 175 DWORD GlobalSize (HANDLE hMem)
 176 {
 177     return LocalSize (hMem);
 178 }
 179
 180 DWORD GlobalCompact(DWORD desired)
 181 {
 182     if (desired)
 183         return desired;
 184     else
 185         return 0x01000000;      /* Should check the available core. */
 186 }
 187
 188 HANDLE GlobalReAlloc(HANDLE hMem, DWORD new_size, WORD flags)
 189 {
 190     if (!(flags & GMEM_MODIFY))
 191         return LocalReAlloc (hMem, new_size, flags);
 192 }
 193
 194 int HEAP_LocalSize ()
 195 {
 196     return 0;
 197 }
 198
 199 int HEAP_LocalFindHeap ()
 200 {
 201     return 0;
 202 }
 203
 204 #ifdef UNIMPLEMENTED
 205
 206 DWORD int GlobalHandle(WORD selector)
 207 {
 208 }
 209
 210 #endif
 211
 212 #else /* WINELIB16 */
 213
 214 #ifdef DEBUG_HEAP
 215 static void* LastTwenty[20]={ 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0  };
 216
 217 void CheckMem(void* f)
 218 {
 219   int i;
 220
 221   for(i=0; i<20; i++)
 222   {
 223     if(LastTwenty[i]==f)
 224       LastTwenty[i]=NULL;
 225     else if(LastTwenty[i])
 226       if( *((int*)LastTwenty[i]) != 0x12345678  ||
 227           *(((int*)LastTwenty[i])+1) != 0x0fedcba9 )
 228         fprintf(stderr,"memory corrupted at %p\n",LastTwenty[i]);
 229   }
 230   fflush(stderr);
 231 }
 232
 233 void NewMem(void* n)
 234 {
 235   int i;
 236   for(i=0; i<20; i++)
 237     if(!LastTwenty[i])
 238     {
 239       LastTwenty[i]=n;
 240       return;
 241     }
 242   for(i=0; i<20; i++)
 243     LastTwenty[i]=LastTwenty[i+1];
 244   LastTwenty[4]=n;
 245 }
 246 #endif
 247
 248 HANDLE LocalAlloc (WORD flags, WORD bytes)
 249 {
 250     HANDLE m;
 251 #ifdef DEBUG_HEAP
 252     bytes+=2*sizeof(int);
 253 #endif
 254
 255     if (flags & LMEM_WINE_ALIGN)
 256         m = memalign (4, bytes);
 257     else
 258         m = malloc (bytes);
 259     if (m){
 260         if (flags & LMEM_ZEROINIT)
 261             bzero (m, bytes);
 262     }
 263 #ifdef DEBUG_HEAP
 264     CheckMem(NULL);
 265     *((int*) m)=0x12345678;
 266     *(((int*) m)+1)=0x0fedcba9;
 267     fprintf(stderr,"%p malloc'd\n",m); fflush(stderr);
 268     NewMem(m);
 269     return (HANDLE) (((int*)m)+2);
 270 #endif
 271     return m;
 272 }
 273
 274 WORD LocalCompact (WORD min_free)
 275 {
 276     return min_free;
 277 }
 278
 279 WORD LocalFlags (HANDLE hMem)
 280 {
 281     return 0;
 282 }
 283
 284 HANDLE LocalFree (HANDLE hMem)
 285 {
 286 #ifdef DEBUG_HEAP
 287     hMem=(HANDLE) (((int*)hMem)-2);
 288     CheckMem(hMem);
 289     fprintf(stderr,"%p free-ing...",hMem);
 290     if( *((int*)hMem) != 0x12345678  ||
 291         *(((int*)hMem)+1) != 0x0fedcba9 )
 292       fprintf(stderr,"memory corrupted...");
 293     else
 294     {
 295       *((int*)hMem) = 0x9abcdef0;
 296       *(((int*)hMem)+1) = 0x87654321;
 297     }
 298     fflush(stderr);
 299 #endif
 300     free(hMem);
 301 #ifdef DEBUG_HEAP
 302     fprintf(stderr,"free'd\n"); fflush(stderr);
 303 #endif
 304     return 0;
 305 }
 306
 307 BOOL LocalInit (HANDLE segment, WORD start, WORD end)
 308 {
 309     return TRUE;
 310 }
 311
 312 LPVOID LocalLock (HANDLE hMem)
 313 {
 314     return hMem;
 315 }
 316
 317 HANDLE LocalReAlloc (HANDLE hMem, WORD flags, WORD bytes)
 318 {
 319 #ifdef DEBUG_HEAP
 320     LocalFree(hMem);
 321     return LocalAlloc(flags,bytes);
 322 #endif
 323     return realloc(hMem, bytes);
 324 }
 325
 326 WORD LocalSize (HANDLE hMem)
 327 {
 328     /* Not implemented yet */
 329   return 0;
 330 }
 331
 332
 333 BOOL LocalUnlock (HANDLE hMem)
 334 {
 335     return 0;
 336 }
 337
 338 HANDLE GlobalAlloc (WORD flags, DWORD size)
 339 {
 340     return LocalAlloc (flags, size);
 341 }
 342
 343 HANDLE GlobalFree (HANDLE hMem)
 344 {
 345     return LocalFree (hMem);
 346 }
 347
 348 LPVOID GlobalLock (HGLOBAL hMem)
 349 {
 350     return LocalLock (hMem);
 351 }
 352
 353 BOOL GlobalUnlock (HANDLE hMem)
 354 {
 355     return LocalUnlock (hMem);
 356 }
 357
 358 WORD GlobalFlags (HANDLE hMem)
 359 {
 360     return LocalFlags (hMem);
 361 }
 362
 363 DWORD GlobalSize (HANDLE hMem)
 364 {
 365     return LocalSize (hMem);
 366 }
 367
 368 DWORD GlobalCompact(DWORD desired)
 369 {
 370     if (desired)
 371         return desired;
 372     else
 373         return 0x01000000;      /* Should check the available core. */
 374 }
 375
 376 HANDLE GlobalReAlloc(HANDLE hMem, DWORD new_size, WORD flags)
 377 {
 378     if (!(flags & GMEM_MODIFY))
 379       return LocalReAlloc (hMem, new_size, flags);
 380     else
 381       return hMem;
 382 }
 383
 384 #endif