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