Mercurial > emacs
comparison gc/pcr_interface.c @ 51488:5de98dce4bd1
*** empty log message ***
author | Dave Love <fx@gnu.org> |
---|---|
date | Thu, 05 Jun 2003 17:49:22 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
51487:01d68b199093 | 51488:5de98dce4bd1 |
---|---|
1 /* | |
2 * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. | |
3 * | |
4 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED | |
5 * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. | |
6 * | |
7 * Permission is hereby granted to use or copy this program | |
8 * for any purpose, provided the above notices are retained on all copies. | |
9 * Permission to modify the code and to distribute modified code is granted, | |
10 * provided the above notices are retained, and a notice that the code was | |
11 * modified is included with the above copyright notice. | |
12 */ | |
13 # include "private/gc_priv.h" | |
14 | |
15 # ifdef PCR | |
16 /* | |
17 * Note that POSIX PCR requires an ANSI C compiler. Hence we are allowed | |
18 * to make the same assumption here. | |
19 * We wrap all of the allocator functions to avoid questions of | |
20 * compatibility between the prototyped and nonprototyped versions of the f | |
21 */ | |
22 # include "config/PCR_StdTypes.h" | |
23 # include "mm/PCR_MM.h" | |
24 # include <errno.h> | |
25 | |
26 # define MY_MAGIC 17L | |
27 # define MY_DEBUGMAGIC 42L | |
28 | |
29 void * GC_AllocProc(size_t size, PCR_Bool ptrFree, PCR_Bool clear ) | |
30 { | |
31 if (ptrFree) { | |
32 void * result = (void *)GC_malloc_atomic(size); | |
33 if (clear && result != 0) BZERO(result, size); | |
34 return(result); | |
35 } else { | |
36 return((void *)GC_malloc(size)); | |
37 } | |
38 } | |
39 | |
40 void * GC_DebugAllocProc(size_t size, PCR_Bool ptrFree, PCR_Bool clear ) | |
41 { | |
42 if (ptrFree) { | |
43 void * result = (void *)GC_debug_malloc_atomic(size, __FILE__, | |
44 __LINE__); | |
45 if (clear && result != 0) BZERO(result, size); | |
46 return(result); | |
47 } else { | |
48 return((void *)GC_debug_malloc(size, __FILE__, __LINE__)); | |
49 } | |
50 } | |
51 | |
52 # define GC_ReallocProc GC_realloc | |
53 void * GC_DebugReallocProc(void * old_object, size_t new_size_in_bytes) | |
54 { | |
55 return(GC_debug_realloc(old_object, new_size_in_bytes, __FILE__, __LINE__)); | |
56 } | |
57 | |
58 # define GC_FreeProc GC_free | |
59 # define GC_DebugFreeProc GC_debug_free | |
60 | |
61 typedef struct { | |
62 PCR_ERes (*ed_proc)(void *p, size_t size, PCR_Any data); | |
63 GC_bool ed_pointerfree; | |
64 PCR_ERes ed_fail_code; | |
65 PCR_Any ed_client_data; | |
66 } enumerate_data; | |
67 | |
68 void GC_enumerate_block(h, ed) | |
69 register struct hblk *h; | |
70 enumerate_data * ed; | |
71 { | |
72 register hdr * hhdr; | |
73 register int sz; | |
74 word *p; | |
75 word * lim; | |
76 | |
77 hhdr = HDR(h); | |
78 sz = hhdr -> hb_sz; | |
79 if (sz >= 0 && ed -> ed_pointerfree | |
80 || sz <= 0 && !(ed -> ed_pointerfree)) return; | |
81 if (sz < 0) sz = -sz; | |
82 lim = (word *)(h+1) - sz; | |
83 p = (word *)h; | |
84 do { | |
85 if (PCR_ERes_IsErr(ed -> ed_fail_code)) return; | |
86 ed -> ed_fail_code = | |
87 (*(ed -> ed_proc))(p, WORDS_TO_BYTES(sz), ed -> ed_client_data); | |
88 p+= sz; | |
89 } while (p <= lim); | |
90 } | |
91 | |
92 struct PCR_MM_ProcsRep * GC_old_allocator = 0; | |
93 | |
94 PCR_ERes GC_EnumerateProc( | |
95 PCR_Bool ptrFree, | |
96 PCR_ERes (*proc)(void *p, size_t size, PCR_Any data), | |
97 PCR_Any data | |
98 ) | |
99 { | |
100 enumerate_data ed; | |
101 | |
102 ed.ed_proc = proc; | |
103 ed.ed_pointerfree = ptrFree; | |
104 ed.ed_fail_code = PCR_ERes_okay; | |
105 ed.ed_client_data = data; | |
106 GC_apply_to_all_blocks(GC_enumerate_block, &ed); | |
107 if (ed.ed_fail_code != PCR_ERes_okay) { | |
108 return(ed.ed_fail_code); | |
109 } else { | |
110 /* Also enumerate objects allocated by my predecessors */ | |
111 return((*(GC_old_allocator->mmp_enumerate))(ptrFree, proc, data)); | |
112 } | |
113 } | |
114 | |
115 void GC_DummyFreeProc(void *p) {} | |
116 | |
117 void GC_DummyShutdownProc(void) {} | |
118 | |
119 struct PCR_MM_ProcsRep GC_Rep = { | |
120 MY_MAGIC, | |
121 GC_AllocProc, | |
122 GC_ReallocProc, | |
123 GC_DummyFreeProc, /* mmp_free */ | |
124 GC_FreeProc, /* mmp_unsafeFree */ | |
125 GC_EnumerateProc, | |
126 GC_DummyShutdownProc /* mmp_shutdown */ | |
127 }; | |
128 | |
129 struct PCR_MM_ProcsRep GC_DebugRep = { | |
130 MY_DEBUGMAGIC, | |
131 GC_DebugAllocProc, | |
132 GC_DebugReallocProc, | |
133 GC_DummyFreeProc, /* mmp_free */ | |
134 GC_DebugFreeProc, /* mmp_unsafeFree */ | |
135 GC_EnumerateProc, | |
136 GC_DummyShutdownProc /* mmp_shutdown */ | |
137 }; | |
138 | |
139 GC_bool GC_use_debug = 0; | |
140 | |
141 void GC_pcr_install() | |
142 { | |
143 PCR_MM_Install((GC_use_debug? &GC_DebugRep : &GC_Rep), &GC_old_allocator); | |
144 } | |
145 | |
146 PCR_ERes | |
147 PCR_GC_Setup(void) | |
148 { | |
149 return PCR_ERes_okay; | |
150 } | |
151 | |
152 PCR_ERes | |
153 PCR_GC_Run(void) | |
154 { | |
155 | |
156 if( !PCR_Base_TestPCRArg("-nogc") ) { | |
157 GC_quiet = ( PCR_Base_TestPCRArg("-gctrace") ? 0 : 1 ); | |
158 GC_use_debug = (GC_bool)PCR_Base_TestPCRArg("-debug_alloc"); | |
159 GC_init(); | |
160 if( !PCR_Base_TestPCRArg("-nogc_incremental") ) { | |
161 /* | |
162 * awful hack to test whether VD is implemented ... | |
163 */ | |
164 if( PCR_VD_Start( 0, NIL, 0) != PCR_ERes_FromErr(ENOSYS) ) { | |
165 GC_enable_incremental(); | |
166 } | |
167 } | |
168 } | |
169 return PCR_ERes_okay; | |
170 } | |
171 | |
172 void GC_push_thread_structures(void) | |
173 { | |
174 /* PCR doesn't work unless static roots are pushed. Can't get here. */ | |
175 ABORT("In GC_push_thread_structures()"); | |
176 } | |
177 | |
178 # endif |