Debian Codegraph @

gc/extra/pcr_interface.c

raw
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 * We wrap all of the allocator functions to avoid questions of
18 * compatibility between the prototyped and nonprototyped versions of the f
19 */
20 # include "config/PCR_StdTypes.h"
21 # include "mm/PCR_MM.h"
22 # include <errno.h>
23
24 # define MY_MAGIC 17L
25 # define MY_DEBUGMAGIC 42L
26
27 void * GC_AllocProc(size_t size, PCR_Bool ptrFree, PCR_Bool clear )
28 {
29 if (ptrFree) {
30 void * result = (void *)GC_malloc_atomic(size);
31 if (clear && result != 0) BZERO(result, size);
32 return(result);
33 } else {
34 return((void *)GC_malloc(size));
35 }
36 }
37
38 void * GC_DebugAllocProc(size_t size, PCR_Bool ptrFree, PCR_Bool clear )
39 {
40 if (ptrFree) {
41 void * result = (void *)GC_debug_malloc_atomic(size, __FILE__,
42 __LINE__);
43 if (clear && result != 0) BZERO(result, size);
44 return(result);
45 } else {
46 return((void *)GC_debug_malloc(size, __FILE__, __LINE__));
47 }
48 }
49
50 # define GC_ReallocProc GC_realloc
51 void * GC_DebugReallocProc(void * old_object, size_t new_size_in_bytes)
52 {
53 return(GC_debug_realloc(old_object, new_size_in_bytes, __FILE__, __LINE__));
54 }
55
56 # define GC_FreeProc GC_free
57 # define GC_DebugFreeProc GC_debug_free
58
59 typedef struct {
60 PCR_ERes (*ed_proc)(void *p, size_t size, PCR_Any data);
61 GC_bool ed_pointerfree;
62 PCR_ERes ed_fail_code;
63 PCR_Any ed_client_data;
64 } enumerate_data;
65
66 void GC_enumerate_block(struct hblk *h, enumerate_data * ed)
67 {
68 hdr * hhdr;
69 size_t sz;
70 ptr_t p;
71 ptr_t lim;
72 word descr;
73
74 # if !defined(CPPCHECK)
75 # error This code was updated without testing.
76 # error and its precursor was clearly broken.
77 # endif
78 hhdr = HDR(h);
79 descr = hhdr -> hb_descr;
80 sz = (size_t)hhdr->hb_sz;
81 if (descr != 0 && ed -> ed_pointerfree
82 || descr == 0 && !(ed -> ed_pointerfree)) return;
83 lim = (ptr_t)(h+1) - sz;
84 p = (ptr_t)h;
85 do {
86 if (PCR_ERes_IsErr(ed -> ed_fail_code)) return;
87 ed -> ed_fail_code =
88 (*(ed -> ed_proc))(p, sz, ed -> ed_client_data);
89 p+= sz;
90 } while ((word)p <= (word)lim);
91 }
92
93 struct PCR_MM_ProcsRep * GC_old_allocator = 0;
94
95 PCR_ERes GC_EnumerateProc(
96 PCR_Bool ptrFree,
97 PCR_ERes (*proc)(void *p, size_t size, PCR_Any data),
98 PCR_Any data
99 )
100 {
101 enumerate_data ed;
102
103 ed.ed_proc = proc;
104 ed.ed_pointerfree = ptrFree;
105 ed.ed_fail_code = PCR_ERes_okay;
106 ed.ed_client_data = data;
107 GC_apply_to_all_blocks(GC_enumerate_block, &ed);
108 if (ed.ed_fail_code != PCR_ERes_okay) {
109 return(ed.ed_fail_code);
110 } else {
111 /* Also enumerate objects allocated by my predecessors */
112 return((*(GC_old_allocator->mmp_enumerate))(ptrFree, proc, data));
113 }
114 }
115
116 void GC_DummyFreeProc(void *p) {}
117
118 void GC_DummyShutdownProc(void) {}
119
120 struct PCR_MM_ProcsRep GC_Rep = {
121 MY_MAGIC,
122 GC_AllocProc,
123 GC_ReallocProc,
124 GC_DummyFreeProc, /* mmp_free */
125 GC_FreeProc, /* mmp_unsafeFree */
126 GC_EnumerateProc,
127 GC_DummyShutdownProc /* mmp_shutdown */
128 };
129
130 struct PCR_MM_ProcsRep GC_DebugRep = {
131 MY_DEBUGMAGIC,
132 GC_DebugAllocProc,
133 GC_DebugReallocProc,
134 GC_DummyFreeProc, /* mmp_free */
135 GC_DebugFreeProc, /* mmp_unsafeFree */
136 GC_EnumerateProc,
137 GC_DummyShutdownProc /* mmp_shutdown */
138 };
139
140 GC_bool GC_use_debug = 0;
141
142 void GC_pcr_install()
143 {
144 PCR_MM_Install((GC_use_debug? &GC_DebugRep : &GC_Rep), &GC_old_allocator);
145 }
146
147 PCR_ERes
148 PCR_GC_Setup(void)
149 {
150 return PCR_ERes_okay;
151 }
152
153 extern GC_bool GC_quiet;
154
155 PCR_ERes
156 PCR_GC_Run(void)
157 {
158
159 if( !PCR_Base_TestPCRArg("-nogc") ) {
160 GC_quiet = ( PCR_Base_TestPCRArg("-gctrace") ? 0 : 1 );
161 GC_use_debug = (GC_bool)PCR_Base_TestPCRArg("-debug_alloc");
162 GC_init();
163 if( !PCR_Base_TestPCRArg("-nogc_incremental") ) {
164 /*
165 * awful hack to test whether VD is implemented ...
166 */
167 if( PCR_VD_Start( 0, NIL, 0) != PCR_ERes_FromErr(ENOSYS) ) {
168 GC_enable_incremental();
169 }
170 }
171 }
172 return PCR_ERes_okay;
173 }
174
175 void GC_push_thread_structures(void)
176 {
177 /* PCR doesn't work unless static roots are pushed. Can't get here. */
178 ABORT("In GC_push_thread_structures()");
179 }
180
181 # endif