~ubuntu-branches/ubuntu/hardy/libgc/hardy-updates : contents of MacOS.c at revision 10

~ubuntu-branches/ubuntu/hardy/libgc/hardy-updates : (revision 10)

/*
	MacOS.c
	
	Some routines for the Macintosh OS port of the Hans-J. Boehm, Alan J. Demers
	garbage collector.
	
	<Revision History>
	
	11/22/94  pcb  StripAddress the temporary memory handle for 24-bit mode.
	11/30/94  pcb  Tracking all memory usage so we can deallocate it all at once.
	02/10/96  pcb  Added routine to perform a final collection when
unloading shared library.
	
	by Patrick C. Beard.
 */
/* Boehm, February 15, 1996 2:55 pm PST */

#include <Resources.h>
#include <Memory.h>
#include <LowMem.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "gc.h"
#include "gc_priv.h"

// use 'CODE' resource 0 to get exact location of the beginning of global space.

typedef struct {
	unsigned long aboveA5;
	unsigned long belowA5;
	unsigned long JTSize;
	unsigned long JTOffset;
} *CodeZeroPtr, **CodeZeroHandle;

void* GC_MacGetDataStart()
{
	CodeZeroHandle code0 = (CodeZeroHandle)GetResource('CODE', 0);
	if (code0) {
		long belowA5Size = (**code0).belowA5;
		ReleaseResource((Handle)code0);
		return (LMGetCurrentA5() - belowA5Size);
	}
	fprintf(stderr, "Couldn't load the jump table.");
	exit(-1);
	return 0;
}

/* track the use of temporary memory so it can be freed all at once. */

typedef struct TemporaryMemoryBlock TemporaryMemoryBlock, **TemporaryMemoryHandle;

struct TemporaryMemoryBlock {
	TemporaryMemoryHandle nextBlock;
	char data[];
};

static TemporaryMemoryHandle theTemporaryMemory = NULL;
static Boolean firstTime = true;

void GC_MacFreeTemporaryMemory(void);

Ptr GC_MacTemporaryNewPtr(size_t size, Boolean clearMemory)
{
	static Boolean firstTime = true;
	OSErr result;
	TemporaryMemoryHandle tempMemBlock;
	Ptr tempPtr = nil;

	tempMemBlock = (TemporaryMemoryHandle)TempNewHandle(size + sizeof(TemporaryMemoryBlock), &result);
	if (tempMemBlock && result == noErr) {
		HLockHi((Handle)tempMemBlock);
		tempPtr = (**tempMemBlock).data;
		if (clearMemory) memset(tempPtr, 0, size);
		tempPtr = StripAddress(tempPtr);

		// keep track of the allocated blocks.
		(**tempMemBlock).nextBlock = theTemporaryMemory;
		theTemporaryMemory = tempMemBlock;
	}
	
#     if !defined(SHARED_LIBRARY_BUILD)
	// install an exit routine to clean up the memory used at the end.
	if (firstTime) {
		atexit(&GC_MacFreeTemporaryMemory);
		firstTime = false;
	}
#     endif
	
	return tempPtr;
}

extern word GC_fo_entries; 

static void perform_final_collection()
{
  unsigned i;
  word last_fo_entries = 0;
  
  /* adjust the stack bottom, because CFM calls us from another stack
     location. */
     GC_stackbottom = (ptr_t)&i;

  /* try to collect and finalize everything in sight */
    for (i = 0; i < 2 || GC_fo_entries < last_fo_entries; i++) {
        last_fo_entries = GC_fo_entries;
        GC_gcollect();
    }
}


void GC_MacFreeTemporaryMemory()
{
# if defined(SHARED_LIBRARY_BUILD)
    /* if possible, collect all memory, and invoke all finalizers. */
      perform_final_collection();
# endif

    if (theTemporaryMemory != NULL) {
	long totalMemoryUsed = 0;
	TemporaryMemoryHandle tempMemBlock = theTemporaryMemory;
	while (tempMemBlock != NULL) {
		TemporaryMemoryHandle nextBlock = (**tempMemBlock).nextBlock;
		totalMemoryUsed += GetHandleSize((Handle)tempMemBlock);
		DisposeHandle((Handle)tempMemBlock);
		tempMemBlock = nextBlock;
	}
	theTemporaryMemory = NULL;

#       if !defined(SILENT) && !defined(SHARED_LIBRARY_BUILD)
          fprintf(stdout, "[total memory used:  %ld bytes.]\n",
                  totalMemoryUsed);
          fprintf(stdout, "[total collections:  %ld.]\n", GC_gc_no);
#       endif
    }
}

#if __option(far_data)

  void* GC_MacGetDataEnd()
  {
	CodeZeroHandle code0 = (CodeZeroHandle)GetResource('CODE', 0);
	if (code0) {
		long aboveA5Size = (**code0).aboveA5;
		ReleaseResource((Handle)code0);
		return (LMGetCurrentA5() + aboveA5Size);
	}
	fprintf(stderr, "Couldn't load the jump table.");
	exit(-1);
	return 0;
  }

#endif /* __option(far_data) */

1 by Ryan Murray Import upstream version 6.0+6.1alpha4	1	/*
	2	MacOS.c
	3
	4	Some routines for the Macintosh OS port of the Hans-J. Boehm, Alan J. Demers
	5	garbage collector.
	6
	7	<Revision History>
	8
	9	11/22/94 pcb StripAddress the temporary memory handle for 24-bit mode.
	10	11/30/94 pcb Tracking all memory usage so we can deallocate it all at once.
	11	02/10/96 pcb Added routine to perform a final collection when
	12	unloading shared library.
	13
	14	by Patrick C. Beard.
	15	*/
	16	/* Boehm, February 15, 1996 2:55 pm PST */
	17
	18	#include <Resources.h>
	19	#include <Memory.h>
	20	#include <LowMem.h>
	21	#include <stdio.h>
	22	#include <stdlib.h>
	23	#include <string.h>
	24
	25	#include "gc.h"
	26	#include "gc_priv.h"
	27
	28	// use 'CODE' resource 0 to get exact location of the beginning of global space.
	29
	30	typedef struct {
	31	unsigned long aboveA5;
	32	unsigned long belowA5;
	33	unsigned long JTSize;
	34	unsigned long JTOffset;
	35	} CodeZeroPtr, *CodeZeroHandle;
	36
	37	void* GC_MacGetDataStart()
	38	{
	39	CodeZeroHandle code0 = (CodeZeroHandle)GetResource('CODE', 0);
	40	if (code0) {
	41	long belowA5Size = (**code0).belowA5;
	42	ReleaseResource((Handle)code0);
	43	return (LMGetCurrentA5() - belowA5Size);
	44	}
	45	fprintf(stderr, "Couldn't load the jump table.");
	46	exit(-1);
	47	return 0;
	48	}
	49
	50	/* track the use of temporary memory so it can be freed all at once. */
	51
	52	typedef struct TemporaryMemoryBlock TemporaryMemoryBlock, **TemporaryMemoryHandle;
	53
	54	struct TemporaryMemoryBlock {
	55	TemporaryMemoryHandle nextBlock;
	56	char data[];
	57	};
	58
	59	static TemporaryMemoryHandle theTemporaryMemory = NULL;
	60	static Boolean firstTime = true;
	61
	62	void GC_MacFreeTemporaryMemory(void);
	63
	64	Ptr GC_MacTemporaryNewPtr(size_t size, Boolean clearMemory)
65	{
66	static Boolean firstTime = true;
67	OSErr result;
68	TemporaryMemoryHandle tempMemBlock;
69	Ptr tempPtr = nil;
70
71	tempMemBlock = (TemporaryMemoryHandle)TempNewHandle(size + sizeof(TemporaryMemoryBlock), &result);
72	if (tempMemBlock && result == noErr) {
73	HLockHi((Handle)tempMemBlock);
74	tempPtr = (**tempMemBlock).data;
75	if (clearMemory) memset(tempPtr, 0, size);
76	tempPtr = StripAddress(tempPtr);
77
78	// keep track of the allocated blocks.
79	(**tempMemBlock).nextBlock = theTemporaryMemory;
80	theTemporaryMemory = tempMemBlock;
81	}
82
83	# if !defined(SHARED_LIBRARY_BUILD)
84	// install an exit routine to clean up the memory used at the end.
85	if (firstTime) {
86	atexit(&GC_MacFreeTemporaryMemory);
87	firstTime = false;
88	}
89	# endif
90
91	return tempPtr;
92	}
93
94	extern word GC_fo_entries;
95
96	static void perform_final_collection()
97	{
98	unsigned i;
99	word last_fo_entries = 0;
100
101	/* adjust the stack bottom, because CFM calls us from another stack
102	location. */
103	GC_stackbottom = (ptr_t)&i;
104
105	/* try to collect and finalize everything in sight */
106	for (i = 0; i < 2 \|\| GC_fo_entries < last_fo_entries; i++) {
107	last_fo_entries = GC_fo_entries;
108	GC_gcollect();
109	}
110	}
111
112
113	void GC_MacFreeTemporaryMemory()
114	{
115	# if defined(SHARED_LIBRARY_BUILD)
116	/* if possible, collect all memory, and invoke all finalizers. */
117	perform_final_collection();
118	# endif
119
120	if (theTemporaryMemory != NULL) {
121	long totalMemoryUsed = 0;
122	TemporaryMemoryHandle tempMemBlock = theTemporaryMemory;
123	while (tempMemBlock != NULL) {
124	TemporaryMemoryHandle nextBlock = (**tempMemBlock).nextBlock;
125	totalMemoryUsed += GetHandleSize((Handle)tempMemBlock);
126	DisposeHandle((Handle)tempMemBlock);
127	tempMemBlock = nextBlock;
128	}
129	theTemporaryMemory = NULL;
130
131	# if !defined(SILENT) && !defined(SHARED_LIBRARY_BUILD)
132	fprintf(stdout, "[total memory used: %ld bytes.]\n",
133	totalMemoryUsed);
134	fprintf(stdout, "[total collections: %ld.]\n", GC_gc_no);
135	# endif
136	}
137	}
138
139	#if __option(far_data)
140
141	void* GC_MacGetDataEnd()
142	{
143	CodeZeroHandle code0 = (CodeZeroHandle)GetResource('CODE', 0);
144	if (code0) {
145	long aboveA5Size = (**code0).aboveA5;
146	ReleaseResource((Handle)code0);
147	return (LMGetCurrentA5() + aboveA5Size);
148	}
149	fprintf(stderr, "Couldn't load the jump table.");
150	exit(-1);
151	return 0;
152	}
153
154	#endif /* __option(far_data) */