add "#ifdef macintosh" for carbon target
[btb/d2x.git] / mem / mem.c
1 /* $Id: mem.c,v 1.13 2004-08-01 13:01:39 schaffner Exp $ */
2 /*
3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
12 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
13 */
14
15 /*
16  *
17  * Files for debugging memory allocator
18  *
19  *
20  */
21
22 #ifdef HAVE_CONFIG_H
23 #include <conf.h>
24 #endif
25
26 // Warning( "MEM: Too many malloc's!" );
27 // Warning( "MEM: Malloc returnd an already alloced block!" );
28 // Warning( "MEM: Malloc Failed!" );
29 // Warning( "MEM: Freeing the NULL pointer!" );
30 // Warning( "MEM: Freeing a non-malloced pointer!" );
31 // Warning( "MEM: %d/%d check bytes were overwritten at the end of %8x", ec, CHECKSIZE, buffer  );
32 // Warning( "MEM: %d blocks were left allocated!", numleft );
33
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #if defined(__APPLE__) && defined(__MACH__)
38 #include <sys/malloc.h>
39 #elif defined(macintosh)
40 #include <stdlib.h>
41 #else
42 #include <malloc.h>
43 #endif
44 #include "pstypes.h"
45 #include "mono.h"
46 #include "error.h"
47
48 #ifdef MACINTOSH
49
50         #include <Gestalt.h>
51         #include <Memory.h>
52         #include <Processes.h>
53         ubyte virtual_memory_on = 0;
54
55         #if defined(RELEASE) || defined(NDEBUG)
56                 #define MEMSTATS        0
57         #else
58                 #define MEMSTATS        1
59         #endif
60
61         
62         #if MEMSTATS
63                 static  int             sMemStatsFileInitialized        = false;
64                 static  FILE*   sMemStatsFile                           = NULL;
65                 static  char    sMemStatsFileName[32]           = "memstats.txt";
66         #endif  // end of if MEMSTATS
67         
68 #else   // no memstats on pc
69         #define MEMSTATS 0
70 #endif
71
72 #define FULL_MEM_CHECKING 1
73
74 #if defined(FULL_MEM_CHECKING) && !defined(NDEBUG)
75
76 #define CHECKSIZE 16
77 #define CHECKBYTE 0xFC
78
79 #define MAX_INDEX 10000
80
81 static void *MallocBase[MAX_INDEX];
82 static unsigned int MallocSize[MAX_INDEX];
83 static unsigned char Present[MAX_INDEX];
84 static char * Filename[MAX_INDEX];
85 static char * Varname[MAX_INDEX];
86 static int LineNum[MAX_INDEX];
87 static int BytesMalloced = 0;
88
89 int show_mem_info = 1;
90
91 static int free_list[MAX_INDEX];
92
93 static int num_blocks = 0;
94
95 static int Initialized = 0;
96
97 static int LargestIndex = 0;
98
99 int out_of_memory = 0;
100
101 void mem_display_blocks();
102
103 void mem_init()
104 {
105         int i;
106         
107         Initialized = 1;
108
109         for (i=0; i<MAX_INDEX; i++ )
110         {
111                 free_list[i] = i;
112                 MallocBase[i] = 0;
113                 MallocSize[i] = 0;
114                 Present[i] = 0;
115                 Filename[i] = NULL;
116                 Varname[i] = NULL;
117                 LineNum[i] = 0;
118         }
119
120         num_blocks = 0;
121         LargestIndex = 0;
122
123         atexit(mem_display_blocks);
124         
125 #ifdef MACINTOSH
126
127 // need to check for virtual memory since we will need to do some
128 // tricks based on whether it is on or not
129
130         {
131                 int                     mem_type;
132                 THz                             theD2PartionPtr = nil;
133                 unsigned long   thePartitionSize = 0;
134                 
135                 MaxApplZone();
136                 MoreMasters();                  // allocate 240 more master pointers (mainly for snd handles)
137                 MoreMasters();
138                 MoreMasters();
139                 MoreMasters();
140                 virtual_memory_on = 0;
141                 if(Gestalt(gestaltVMAttr, &mem_type) == noErr)
142                         if (mem_type & 0x1)
143                                 virtual_memory_on = 1;
144                                 
145                 #if MEMSTATS
146                         sMemStatsFile = fopen(sMemStatsFileName, "wt");
147         
148                         if (sMemStatsFile != NULL)
149                         {
150                                 sMemStatsFileInitialized = true;
151         
152                                 theD2PartionPtr = ApplicationZone();
153                                 thePartitionSize =  ((unsigned long) theD2PartionPtr->bkLim) - ((unsigned long) theD2PartionPtr);
154                                 fprintf(sMemStatsFile, "\nMemory Stats File Initialized.");
155                                 fprintf(sMemStatsFile, "\nDescent 2 launched in partition of %u bytes.\n",
156                                                 thePartitionSize);
157                         }
158                 #endif  // end of ifdef MEMSTATS
159         }
160
161 #endif  // end of ifdef macintosh
162
163 }
164
165 void PrintInfo( int id )
166 {
167         fprintf( stderr, "\tBlock '%s' created in %s, line %d.\n", Varname[id], Filename[id], LineNum[id] );
168 }
169
170
171 void * mem_malloc( unsigned int size, char * var, char * filename, int line, int fill_zero )
172 {
173         int i, id;
174         void *ptr;
175         char * pc;
176
177         if (Initialized==0)
178                 mem_init();
179
180 //      printf("malloc: %d %s %d\n", size, filename, line);
181
182 #if MEMSTATS
183         {
184                 unsigned long   theFreeMem = 0;
185         
186                 if (sMemStatsFileInitialized)
187                 {
188                         theFreeMem = FreeMem();
189                 
190                         fprintf(sMemStatsFile,
191                                         "\n%9u bytes free before attempting: MALLOC %9u bytes.",
192                                         theFreeMem,
193                                         size);
194                 }
195         }
196 #endif  // end of ifdef memstats
197
198         if ( num_blocks >= MAX_INDEX )  {
199                 fprintf( stderr,"\nMEM_OUT_OF_SLOTS: Not enough space in mem.c to hold all the mallocs.\n" );           
200                 fprintf( stderr, "\tBlock '%s' created in %s, line %d.\n", var, filename, line );
201                 Error( "MEM_OUT_OF_SLOTS" );
202         }
203
204         id = free_list[ num_blocks++ ];
205
206         if (id > LargestIndex ) LargestIndex = id;
207
208         if (id==-1)
209         {
210                 fprintf( stderr,"\nMEM_OUT_OF_SLOTS: Not enough space in mem.c to hold all the mallocs.\n" );           
211                 fprintf( stderr, "\tBlock '%s' created in %s, line %d.\n", Varname[id], Filename[id], LineNum[id] );
212                 Error( "MEM_OUT_OF_SLOTS" );
213         }
214
215 #ifndef MACINTOSH
216         ptr = malloc( size+CHECKSIZE );
217 #else
218         ptr = (void *)NewPtrClear( size+CHECKSIZE );
219 #endif
220
221         /*
222         for (j=0; j<=LargestIndex; j++ )
223         {
224                 if (Present[j] && MallocBase[j] == (unsigned int)ptr )
225                 {
226                         fprintf( stderr,"\nMEM_SPACE_USED: Malloc returned a block that is already marked as preset.\n" );
227                         fprintf( stderr, "\tBlock '%s' created in %s, line %d.\n", Varname[id], Filename[id], Line[id] );
228                         Warning( "MEM_SPACE_USED" );
229                         Int3();
230                         }
231         }
232         */
233
234         if (ptr==NULL)
235         {
236                 out_of_memory = 1;
237                 fprintf( stderr, "\nMEM_OUT_OF_MEMORY: Malloc returned NULL\n" );
238                 fprintf( stderr, "\tBlock '%s' created in %s, line %d.\n", Varname[id], Filename[id], LineNum[id] );
239                 Error( "MEM_OUT_OF_MEMORY" );
240         }
241
242         MallocBase[id] = ptr;
243         MallocSize[id] = size;
244         Varname[id] = var;
245         Filename[id] = filename;
246         LineNum[id] = line;
247         Present[id]    = 1;
248
249         pc = (char *)ptr;
250
251         BytesMalloced += size;
252
253         for (i=0; i<CHECKSIZE; i++ )
254                 pc[size+i] = CHECKBYTE;
255
256         if (fill_zero)
257                 memset( ptr, 0, size );
258
259         return ptr;
260
261 }
262
263 int mem_find_id( void * buffer )
264 {
265         int i;
266
267         for (i=0; i<=LargestIndex; i++ )
268           if (Present[i]==1)
269             if (MallocBase[i] == buffer )
270               return i;
271
272         // Didn't find id.
273         return -1;
274 }
275
276 int mem_check_integrity( int block_number )
277 {
278         int i, ErrorCount;
279         ubyte * CheckData;
280
281         CheckData = (char *)((char *)MallocBase[block_number] + MallocSize[block_number]);
282
283         ErrorCount = 0;
284                         
285         for (i=0; i<CHECKSIZE; i++ )
286                 if (CheckData[i] != CHECKBYTE ) {
287                         ErrorCount++;
288                         fprintf( stderr, "OA: %p ", &CheckData[i] );
289                 }
290
291         if (ErrorCount &&  (!out_of_memory))    {
292                 fprintf( stderr, "\nMEM_OVERWRITE: Memory after the end of allocated block overwritten.\n" );
293                 PrintInfo( block_number );
294                 fprintf( stderr, "\t%d/%d check bytes were overwritten.\n", ErrorCount, CHECKSIZE );
295                 Int3();
296         }
297
298         return ErrorCount;
299
300 }
301
302 void mem_free( void * buffer )
303 {
304         int id;
305
306         if (Initialized==0)
307                 mem_init();
308
309 #if MEMSTATS
310         {
311                 unsigned long   theFreeMem = 0;
312         
313                 if (sMemStatsFileInitialized)
314                 {
315                         theFreeMem = FreeMem();
316                 
317                         fprintf(sMemStatsFile,
318                                         "\n%9u bytes free before attempting: FREE", theFreeMem);
319                 }
320         }
321 #endif  // end of ifdef memstats
322
323         if (buffer==NULL  &&  (!out_of_memory))
324         {
325                 fprintf( stderr, "\nMEM_FREE_NULL: An attempt was made to free the null pointer.\n" );
326                 Warning( "MEM: Freeing the NULL pointer!" );
327                 Int3();
328                 return;
329         }
330
331         id = mem_find_id( buffer );
332
333         if (id==-1 &&  (!out_of_memory))
334         {
335                 fprintf( stderr, "\nMEM_FREE_NOMALLOC: An attempt was made to free a ptr that wasn't\nallocated with mem.h included.\n" );
336                 Warning( "MEM: Freeing a non-malloced pointer!" );
337                 Int3();
338                 return;
339         }
340         
341         mem_check_integrity( id );
342         
343         BytesMalloced -= MallocSize[id];
344
345 #ifndef MACINTOSH
346         free( buffer );
347 #else
348         DisposePtr( (Ptr)buffer );
349 #endif
350         
351         
352         Present[id] = 0;
353         MallocBase[id] = 0;
354         MallocSize[id] = 0;
355
356         free_list[ --num_blocks ] = id;
357 }
358
359 void *mem_realloc(void * buffer, unsigned int size, char * var, char * filename, int line)
360 {
361         void *newbuffer;
362         int id;
363
364         if (Initialized==0)
365                 mem_init();
366
367         if (size == 0) {
368                 mem_free(buffer);
369                 newbuffer = NULL;
370         } else if (buffer == NULL) {
371                 newbuffer = mem_malloc(size, var, filename, line, 0);
372         } else {
373                 newbuffer = mem_malloc(size, var, filename, line, 0);
374                 if (newbuffer != NULL) {
375                         id = mem_find_id(buffer);
376                         if (MallocSize[id] < size)
377                                 size = MallocSize[id];
378                         memcpy(newbuffer, buffer, size);
379                         mem_free(buffer);
380                 }
381         }
382         return newbuffer;
383 }
384
385 char *mem_strdup(char *str, char *var, char *filename, int line)
386 {
387         char *newstr;
388
389         newstr = mem_malloc(strlen(str) + 1, var, filename, line, 0);
390         strcpy(newstr, str);
391
392         return newstr;
393 }
394
395 void mem_display_blocks()
396 {
397         int i, numleft;
398
399         if (Initialized==0) return;
400         
401 #if MEMSTATS
402         {       
403                 if (sMemStatsFileInitialized)
404                 {
405                         unsigned long   theFreeMem = 0;
406
407                         theFreeMem = FreeMem();
408                 
409                         fprintf(sMemStatsFile,
410                                         "\n%9u bytes free before closing MEMSTATS file.", theFreeMem);
411                         fprintf(sMemStatsFile, "\nMemory Stats File Closed.");
412                         fclose(sMemStatsFile);
413                 }
414         }
415 #endif  // end of ifdef memstats
416
417         numleft = 0;
418         for (i=0; i<=LargestIndex; i++ )
419         {
420                 if (Present[i]==1 &&  (!out_of_memory))
421                 {
422                         numleft++;
423                         if (show_mem_info)      {
424                                 fprintf( stderr, "\nMEM_LEAKAGE: Memory block has not been freed.\n" );
425                                 PrintInfo( i );
426                         }
427                         mem_free( (void *)MallocBase[i] );
428                 }
429         }
430
431         if (numleft &&  (!out_of_memory))
432         {
433                 Warning( "MEM: %d blocks were left allocated!\n", numleft );
434         }
435
436 }
437
438 void mem_validate_heap()
439 {
440         int i;
441         
442         for (i=0; i<LargestIndex; i++  )
443                 if (Present[i]==1 )
444                         mem_check_integrity( i );
445 }
446
447 void mem_print_all()
448 {
449         FILE * ef;
450         int i, size = 0;
451
452         ef = fopen( "DESCENT.MEM", "wt" );
453         
454         for (i=0; i<LargestIndex; i++  )
455                 if (Present[i]==1 )     {
456                         size += MallocSize[i];
457                         //fprintf( ef, "Var:%s\t File:%s\t Line:%d\t Size:%d Base:%x\n", Varname[i], Filename[i], Line[i], MallocSize[i], MallocBase[i] );
458                         fprintf( ef, "%12d bytes in %s declared in %s, line %d\n", MallocSize[i], Varname[i], Filename[i], LineNum[i]  );
459                 }
460         fprintf( ef, "%d bytes (%d Kbytes) allocated.\n", size, size/1024 ); 
461         fclose(ef);
462 }
463
464 #else
465
466 static int Initialized = 0;
467 static unsigned int SmallestAddress = 0xFFFFFFF;
468 static unsigned int LargestAddress = 0x0;
469 static unsigned int BytesMalloced = 0;
470
471 void mem_display_blocks();
472
473 #define CHECKSIZE 16
474 #define CHECKBYTE 0xFC
475
476 int show_mem_info = 0;
477
478 void mem_init()
479 {
480         Initialized = 1;
481
482         SmallestAddress = 0xFFFFFFF;
483         LargestAddress = 0x0;
484
485         atexit(mem_display_blocks);
486
487 #ifdef MACINTOSH
488
489         // need to check for virtual memory since we will need to do some
490         // tricks based on whether it is on or not
491         
492         {
493                 int                     mem_type;
494                 THz                             theD2PartionPtr = nil;
495                 unsigned long   thePartitionSize = 0;
496                 
497                 MaxApplZone();
498                 MoreMasters();          // allocate 240 more master pointers (mainly for snd handles)
499                 MoreMasters();
500                 MoreMasters();
501                 MoreMasters();
502                 virtual_memory_on = 0;
503                 if(Gestalt(gestaltVMAttr, &mem_type) == noErr)
504                         if (mem_type & 0x1)
505                                 virtual_memory_on = 1;
506                                 
507                 #if MEMSTATS
508                         sMemStatsFile = fopen(sMemStatsFileName, "wt");
509
510                         if (sMemStatsFile != NULL)
511                         {
512                                 sMemStatsFileInitialized = true;
513
514                                 theD2PartionPtr = ApplicationZone();
515                                 thePartitionSize =  ((unsigned long) theD2PartionPtr->bkLim) - ((unsigned long) theD2PartionPtr);
516                                 fprintf(sMemStatsFile, "\nMemory Stats File Initialized.");
517                                 fprintf(sMemStatsFile, "\nDescent 2 launched in partition of %u bytes.\n",
518                                                 thePartitionSize);
519                         }
520                 #endif  // end of ifdef memstats
521         }
522         
523 #endif  // end of ifdef macintosh
524
525 }
526
527 void * mem_malloc( unsigned int size, char * var, char * filename, int line, int fill_zero )
528 {
529         unsigned int base;
530         void *ptr;
531         int * psize;
532
533         if (Initialized==0)
534                 mem_init();
535
536 #if MEMSTATS
537         {
538                 unsigned long   theFreeMem = 0;
539         
540                 if (sMemStatsFileInitialized)
541                 {
542                         theFreeMem = FreeMem();
543                 
544                         fprintf(sMemStatsFile,
545                                         "\n%9u bytes free before attempting: MALLOC %9u bytes.",
546                                         theFreeMem,
547                                         size);
548                 }
549         }
550 #endif  // end of ifdef memstats
551
552         if (size==0)    {
553                 fprintf( stderr, "\nMEM_MALLOC_ZERO: Attempting to malloc 0 bytes.\n" );
554                 fprintf( stderr, "\tVar %s, file %s, line %d.\n", var, filename, line );
555                 Error( "MEM_MALLOC_ZERO" );
556                 Int3();
557         }
558
559 #ifndef MACINTOSH
560         ptr = malloc( size + CHECKSIZE );
561 #else
562         ptr = (void *)NewPtrClear( size+CHECKSIZE );
563 #endif
564
565         if (ptr==NULL)  {
566                 fprintf( stderr, "\nMEM_OUT_OF_MEMORY: Malloc returned NULL\n" );
567                 fprintf( stderr, "\tVar %s, file %s, line %d.\n", var, filename, line );
568                 Error( "MEM_OUT_OF_MEMORY" );
569                 Int3();
570         }
571
572         base = (unsigned int)ptr;
573         if ( base < SmallestAddress ) SmallestAddress = base;
574         if ( (base+size) > LargestAddress ) LargestAddress = base+size;
575
576
577         psize = (int *)ptr;
578         psize--;
579         BytesMalloced += *psize;
580
581         if (fill_zero)
582                 memset( ptr, 0, size );
583
584         return ptr;
585 }
586
587 void mem_free( void * buffer )
588 {
589         int * psize = (int *)buffer;
590         psize--;
591
592         if (Initialized==0)
593                 mem_init();
594
595 #if MEMSTATS
596         {
597                 unsigned long   theFreeMem = 0;
598         
599                 if (sMemStatsFileInitialized)
600                 {
601                         theFreeMem = FreeMem();
602                 
603                         fprintf(sMemStatsFile,
604                                         "\n%9u bytes free before attempting: FREE", theFreeMem);
605                 }
606         }
607 #endif  // end of ifdef memstats
608
609         if (buffer==NULL)       {
610                 fprintf( stderr, "\nMEM_FREE_NULL: An attempt was made to free the null pointer.\n" );
611                 Warning( "MEM: Freeing the NULL pointer!" );
612                 Int3();
613                 return;
614         }
615
616         BytesMalloced -= *psize;
617
618 #ifndef MACINTOSH
619         free( buffer );
620 #else
621         DisposePtr( (Ptr)buffer );
622 #endif
623 }
624
625 void mem_display_blocks()
626 {
627         if (Initialized==0) return;
628
629 #if MEMSTATS
630         {       
631                 if (sMemStatsFileInitialized)
632                 {
633                         unsigned long   theFreeMem = 0;
634
635                         theFreeMem = FreeMem();
636                 
637                         fprintf(sMemStatsFile,
638                                         "\n%9u bytes free before closing MEMSTATS file.", theFreeMem);
639                         fprintf(sMemStatsFile, "\nMemory Stats File Closed.");
640                         fclose(sMemStatsFile);
641                 }
642         }
643 #endif  // end of ifdef memstats
644
645         if (BytesMalloced != 0 )        {
646                 fprintf( stderr, "\nMEM_LEAKAGE: %d bytes of memory have not been freed.\n", BytesMalloced );
647         }
648
649         if (show_mem_info)      {
650                 fprintf( stderr, "\n\nMEMORY USAGE:\n" );
651                 fprintf( stderr, "  %u Kbytes dynamic data\n", (LargestAddress-SmallestAddress+512)/1024 );
652                 fprintf( stderr, "  %u Kbytes code/static data.\n", (SmallestAddress-(4*1024*1024)+512)/1024 );
653                 fprintf( stderr, "  ---------------------------\n" );
654                 fprintf( stderr, "  %u Kbytes required.\n",     (LargestAddress-(4*1024*1024)+512)/1024 );
655         }
656 }
657
658 void mem_validate_heap()
659 {
660 }
661
662 void mem_print_all()
663 {
664 }
665
666 #endif
667
668
669 #ifdef MACINTOSH
670
671 // routine to try and compact and purge the process manager zone to squeeze
672 // some temporary memory out of it for QT purposes.
673
674 void PurgeTempMem()
675 {
676         OSErr err;
677         Handle tempHandle;
678         THz appZone, processZone;
679         Size heapSize;
680         
681         // compact the system zone to try and squeeze some temporary memory out of it
682         MaxMemSys(&heapSize);
683         
684         // compact the Process Manager zone to get more temporary memory
685         appZone = ApplicationZone();
686         tempHandle = TempNewHandle(10, &err);           // temporary allocation may fail
687         if (!err && (tempHandle != NULL) ) {
688                 processZone = HandleZone(tempHandle);
689                 if ( MemError() || (processZone == NULL) ) {
690                         DisposeHandle(tempHandle);
691                         return;
692                 }
693                 SetZone(processZone);
694                 MaxMem(&heapSize);                              // purge and compact the Process Manager Zone.
695                 SetZone(appZone);
696                 DisposeHandle(tempHandle);
697         }
698 }
699
700 #endif