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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
from rpython.memory.gctransform.transform import GCTransformer, mallocHelpers
from rpython.memory.gctransform.support import (get_rtti,
_static_deallocator_body_for_type, LLTransformerOp, ll_call_destructor,
ll_report_finalizer_error)
from rpython.rtyper.lltypesystem import lltype, llmemory
from rpython.flowspace.model import Constant
from rpython.rtyper.lltypesystem.lloperation import llop
from rpython.rtyper import rmodel
class BoehmGCTransformer(GCTransformer):
malloc_zero_filled = True
FINALIZER_PTR = lltype.Ptr(lltype.FuncType([llmemory.Address], lltype.Void))
HDR = lltype.Struct("header", ("hash", lltype.Signed))
def __init__(self, translator, inline=False):
super(BoehmGCTransformer, self).__init__(translator, inline=inline)
self.finalizer_funcptrs = {}
atomic_mh = mallocHelpers()
atomic_mh.allocate = lambda size: llop.boehm_malloc_atomic(llmemory.Address, size)
ll_malloc_fixedsize_atomic = atomic_mh._ll_malloc_fixedsize
mh = mallocHelpers()
mh.allocate = lambda size: llop.boehm_malloc(llmemory.Address, size)
ll_malloc_fixedsize = mh._ll_malloc_fixedsize
# XXX, do we need/want an atomic version of this function?
ll_malloc_varsize_no_length = mh.ll_malloc_varsize_no_length
ll_malloc_varsize = mh.ll_malloc_varsize
HDRPTR = lltype.Ptr(self.HDR)
def ll_identityhash(addr):
obj = llmemory.cast_adr_to_ptr(addr, HDRPTR)
h = obj.hash
if h == 0:
obj.hash = h = ~llmemory.cast_adr_to_int(addr)
return h
if self.translator:
self.malloc_fixedsize_ptr = self.inittime_helper(
ll_malloc_fixedsize, [lltype.Signed], llmemory.Address)
self.malloc_fixedsize_atomic_ptr = self.inittime_helper(
ll_malloc_fixedsize_atomic, [lltype.Signed], llmemory.Address)
self.malloc_varsize_no_length_ptr = self.inittime_helper(
ll_malloc_varsize_no_length, [lltype.Signed]*3, llmemory.Address, inline=False)
self.malloc_varsize_ptr = self.inittime_helper(
ll_malloc_varsize, [lltype.Signed]*4, llmemory.Address, inline=False)
if self.translator.config.translation.rweakref:
self.weakref_create_ptr = self.inittime_helper(
ll_weakref_create, [llmemory.Address], llmemory.WeakRefPtr,
inline=False)
self.weakref_deref_ptr = self.inittime_helper(
ll_weakref_deref, [llmemory.WeakRefPtr], llmemory.Address)
self.identityhash_ptr = self.inittime_helper(
ll_identityhash, [llmemory.Address], lltype.Signed,
inline=False)
self.mixlevelannotator.finish() # for now
self.mixlevelannotator.backend_optimize()
self.finalizer_triggers = []
self.finalizer_queue_indexes = {} # {fq: index}
def gct_fv_gc_malloc(self, hop, flags, TYPE, c_size):
# XXX same behavior for zero=True: in theory that's wrong
if TYPE._is_atomic():
funcptr = self.malloc_fixedsize_atomic_ptr
else:
funcptr = self.malloc_fixedsize_ptr
v_raw = hop.genop("direct_call",
[funcptr, c_size],
resulttype=llmemory.Address)
finalizer_ptr = self.finalizer_funcptr_for_type(TYPE)
if finalizer_ptr:
c_finalizer_ptr = Constant(finalizer_ptr, self.FINALIZER_PTR)
hop.genop("boehm_register_finalizer", [v_raw, c_finalizer_ptr])
return v_raw
def gct_fv_gc_malloc_varsize(self, hop, flags, TYPE, v_length, c_const_size, c_item_size,
c_offset_to_length):
# XXX same behavior for zero=True: in theory that's wrong
if c_offset_to_length is None:
v_raw = hop.genop("direct_call",
[self.malloc_varsize_no_length_ptr, v_length,
c_const_size, c_item_size],
resulttype=llmemory.Address)
else:
v_raw = hop.genop("direct_call",
[self.malloc_varsize_ptr, v_length,
c_const_size, c_item_size, c_offset_to_length],
resulttype=llmemory.Address)
return v_raw
def finalizer_funcptr_for_type(self, TYPE):
if TYPE in self.finalizer_funcptrs:
return self.finalizer_funcptrs[TYPE]
rtti = get_rtti(TYPE)
if rtti is not None and hasattr(rtti._obj, 'destructor_funcptr'):
destrptr = rtti._obj.destructor_funcptr
DESTR_ARG = lltype.typeOf(destrptr).TO.ARGS[0]
else:
destrptr = None
DESTR_ARG = None
if destrptr:
EXC_INSTANCE_TYPE = self.translator.rtyper.exceptiondata.lltype_of_exception_value
typename = TYPE.__name__
def ll_finalizer(addr):
exc_instance = llop.gc_fetch_exception(EXC_INSTANCE_TYPE)
v = llmemory.cast_adr_to_ptr(addr, DESTR_ARG)
ll_call_destructor(destrptr, v, typename)
llop.gc_restore_exception(lltype.Void, exc_instance)
fptr = self.annotate_finalizer(ll_finalizer, [llmemory.Address], lltype.Void)
else:
fptr = lltype.nullptr(self.FINALIZER_PTR.TO)
self.finalizer_funcptrs[TYPE] = fptr
return fptr
def get_finalizer_queue_index(self, hop):
fq_tag = hop.spaceop.args[0].value
assert 'FinalizerQueue TAG' in fq_tag.expr
fq = fq_tag.default
try:
index = self.finalizer_queue_indexes[fq]
except KeyError:
index = len(self.finalizer_queue_indexes)
assert index == len(self.finalizer_triggers)
#
def ll_finalizer_trigger():
try:
fq.finalizer_trigger()
except Exception as e:
ll_report_finalizer_error(e)
ll_trigger = self.annotate_finalizer(ll_finalizer_trigger, [],
lltype.Void)
self.finalizer_triggers.append(ll_trigger)
self.finalizer_queue_indexes[fq] = index
return index
def gct_gc_fq_register(self, hop):
index = self.get_finalizer_queue_index(hop)
c_index = rmodel.inputconst(lltype.Signed, index)
v_ptr = hop.spaceop.args[1]
hop.genop("boehm_fq_register", [c_index, v_ptr])
def gct_gc_fq_next_dead(self, hop):
index = self.get_finalizer_queue_index(hop)
c_index = rmodel.inputconst(lltype.Signed, index)
hop.genop("boehm_fq_next_dead", [c_index],
resultvar = hop.spaceop.result)
def gct_weakref_create(self, hop):
v_instance, = hop.spaceop.args
v_addr = hop.genop("cast_ptr_to_adr", [v_instance],
resulttype=llmemory.Address)
v_wref = hop.genop("direct_call",
[self.weakref_create_ptr, v_addr],
resulttype=llmemory.WeakRefPtr)
hop.cast_result(v_wref)
def gct_zero_everything_inside(self, hop):
pass
def gct_zero_gc_pointers_inside(self, hop):
pass
def gct_weakref_deref(self, hop):
v_wref, = hop.spaceop.args
v_addr = hop.genop("direct_call",
[self.weakref_deref_ptr, v_wref],
resulttype=llmemory.Address)
hop.cast_result(v_addr)
def gct_gc_writebarrier_before_copy(self, hop):
# no write barrier needed
op = hop.spaceop
hop.genop("same_as",
[rmodel.inputconst(lltype.Bool, True)],
resultvar=op.result)
def gct_gc_identityhash(self, hop):
v_obj = hop.spaceop.args[0]
v_adr = hop.genop("cast_ptr_to_adr", [v_obj],
resulttype=llmemory.Address)
hop.genop("direct_call", [self.identityhash_ptr, v_adr],
resultvar=hop.spaceop.result)
def gct_gc_id(self, hop):
# this is the logic from the HIDE_POINTER macro in <gc/gc.h>
v_int = hop.genop('cast_ptr_to_int', [hop.spaceop.args[0]],
resulttype = lltype.Signed)
hop.genop('int_invert', [v_int], resultvar=hop.spaceop.result)
def gcheader_initdata(self, obj):
hdr = lltype.malloc(self.HDR, immortal=True)
hdr.hash = lltype.identityhash_nocache(obj._as_ptr())
return hdr._obj
########## weakrefs ##########
# Boehm: weakref objects are small structures containing only a Boehm
# disappearing link. We don't have to hide the link's value with
# HIDE_POINTER(), because we explicitly use GC_MALLOC_ATOMIC().
WEAKLINK = lltype.FixedSizeArray(llmemory.Address, 1)
sizeof_weakreflink = llmemory.sizeof(WEAKLINK)
empty_weaklink = lltype.malloc(WEAKLINK, immortal=True)
empty_weaklink[0] = llmemory.NULL
def ll_weakref_create(targetaddr):
link = llop.boehm_malloc_atomic(llmemory.Address, sizeof_weakreflink)
if not link:
raise MemoryError
plink = llmemory.cast_adr_to_ptr(link, lltype.Ptr(WEAKLINK))
plink[0] = targetaddr
llop.boehm_disappearing_link(lltype.Void, link, targetaddr)
return llmemory.cast_ptr_to_weakrefptr(plink)
def ll_weakref_deref(wref):
plink = llmemory.cast_weakrefptr_to_ptr(lltype.Ptr(WEAKLINK), wref)
return plink[0]
def convert_weakref_to(targetptr):
# Prebuilt weakrefs don't really need to be weak at all,
# but we need to emulate the structure expected by ll_weakref_deref().
# This is essentially the same code as in ll_weakref_create(), but I'm
# not sure trying to share it is worth the hassle...
if not targetptr:
return empty_weaklink
else:
plink = lltype.malloc(WEAKLINK, immortal=True)
plink[0] = llmemory.cast_ptr_to_adr(targetptr)
return plink
|
