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