def transform_graph(self, graph):
if graph in self.minimal_transform:
if self.minimalgctransformer:
self.minimalgctransformer.transform_graph(graph)
del self.minimal_transform[graph]
return
if graph in self.seen_graphs:
return
self.seen_graphs[graph] = True
self.links_to_split = {} # link -> vars to pop_alive across the link
# for sanity, we need an empty block at the start of the graph
inserted_empty_startblock = False
if not starts_with_empty_block(graph):
insert_empty_startblock(self.translator.annotator, graph)
inserted_empty_startblock = True
is_borrowed = self.compute_borrowed_vars(graph)
for block in graph.iterblocks():
self.transform_block(block, is_borrowed)
for link, livecounts in self.links_to_split.iteritems():
llops = LowLevelOpList()
for var, livecount in livecounts.iteritems():
for i in range(livecount):
self.pop_alive(var, llops)
for i in range(-livecount):
self.push_alive(var, llops)
if llops:
if link.prevblock.exitswitch is None:
link.prevblock.operations.extend(llops)
else:
insert_empty_block(self.translator.annotator, link, llops)
# remove the empty block at the start of the graph, which should
# still be empty (but let's check)
if starts_with_empty_block(graph) and inserted_empty_startblock:
old_startblock = graph.startblock
graph.startblock.isstartblock = False
graph.startblock = graph.startblock.exits[0].target
graph.startblock.isstartblock = True
checkgraph(graph)
self.links_to_split = None
v = Variable('vanishing_exc_value')
v.concretetype = self.get_lltype_of_exception_value()
llops = LowLevelOpList()
self.pop_alive(v, llops)
graph.exc_cleanup = (v, list(llops))
return is_borrowed # xxx for tests only
def kill_assertion_link(graph, link):
block = link.prevblock
exits = list(block.exits)
if len(exits) <= 1:
return False
remove_condition = len(exits) == 2
if block.exitswitch == c_last_exception:
if link is exits[0]:
return False # cannot remove the non-exceptional path
else:
if block.exitswitch.concretetype is not lltype.Bool: # a switch
remove_condition = False
else:
# common case: if <cond>: raise AssertionError
# turn it into a debug_assert operation
assert remove_condition
newops = LowLevelOpList()
if link.exitcase:
v = newops.genop('bool_not', [block.exitswitch],
resulttype=lltype.Bool)
else:
v = block.exitswitch
msg = "assertion failed in %s" % (graph.name, )
c_msg = inputconst(lltype.Void, msg)
newops.genop('debug_assert', [v, c_msg])
block.operations.extend(newops)
exits.remove(link)
if remove_condition:
# condition no longer necessary
block.exitswitch = None
exits[0].exitcase = None
exits[0].llexitcase = None
block.recloseblock(*exits)
return True
def test_nclc_nongc_not_passed_on():
# +--- inputargs: pointer_to_gc
# | v0 <- op_getsubstruct pointer_to_gc 'b'
# +--- exitargs: pointer_to_gc (i.e. the pointer to non-gc doesn't leave the block)
llops = LowLevelOpList()
ptr_a = varoftype(lltype.Ptr(GcA))
v_res = llops.genop("getsubstruct", [ptr_a, model.Constant('b', lltype.Void)],
resulttype=lltype.Ptr(NonGcB))
block = model.Block([ptr_a])
block.operations.extend(llops)
block.closeblock(model.Link([ptr_a], None))
assert not needs_conservative_livevar_calculation(block)
def test_nclc_should_be_true():
# this is testing a block like:
# +--- inputargs: pointer_to_gc
# | v0 <- op_getsubstruct pointer_to_gc 'b'
# +--- exitargs: v0 (i.e. pointer to non-gc)
llops = LowLevelOpList()
ptr_a = varoftype(lltype.Ptr(GcA))
v_res = llops.genop("getsubstruct", [ptr_a, model.Constant('b', lltype.Void)],
resulttype=lltype.Ptr(NonGcB))
block = model.Block([ptr_a])
block.operations.extend(llops)
block.closeblock(model.Link([v_res], None))
assert needs_conservative_livevar_calculation(block)
def transform_block(self, block, is_borrowed):
llops = LowLevelOpList()
#self.curr_block = block
self.livevars = [
var for var in block.inputargs
if var_needsgc(var) and not is_borrowed(var)
]
allvars = [var for var in block.getvariables() if var_needsgc(var)]
self.var_last_needed_in = dict.fromkeys(allvars, 0)
for i, op in enumerate(block.operations):
for var in op.args:
if not var_needsgc(var):
continue
self.var_last_needed_in[var] = i
for link in block.exits:
for var in link.args:
if not var_needsgc(var):
continue
self.var_last_needed_in[var] = len(block.operations) + 1
for i, op in enumerate(block.operations):
hop = GcHighLevelOp(self, op, i, llops)
hop.dispatch()
if len(block.exits) != 0: # i.e not the return block
assert block.exitswitch is not c_last_exception
deadinallexits = set(self.livevars)
for link in block.exits:
deadinallexits.difference_update(set(link.args))
for var in deadinallexits:
self.pop_alive(var, llops)
for link in block.exits:
livecounts = dict.fromkeys(
set(self.livevars) - deadinallexits, 1)
for v, v2 in zip(link.args, link.target.inputargs):
if is_borrowed(v2):
continue
if v in livecounts:
livecounts[v] -= 1
elif var_needsgc(v):
# 'v' is typically a Constant here, but it can be
# a borrowed variable going into a non-borrowed one
livecounts[v] = -1
self.links_to_split[link] = livecounts
block.operations[:] = llops
self.livevars = None
self.var_last_needed_in = None
def write_barrier_check(spaceop, needs_write_barrier=True):
t = TranslationContext()
t.buildannotator().build_types(lambda x: x, [SomeInteger()])
t.buildrtyper().specialize()
transformer = WriteBarrierTransformer(t)
llops = LowLevelOpList()
hop = GcHighLevelOp(transformer, spaceop, 0, llops)
hop.dispatch()
found = False
print spaceop, '======>'
for op in llops:
print '\t', op
if op.opname == 'direct_call':
found = True
assert found == needs_write_barrier
def test_sbwk_should_insert_keepalives():
# this is testing something like:
# v0 <- op_producing_non_gc
# v1 <- op_using_v0 <- split here
llops = LowLevelOpList()
ptr_a = varoftype(lltype.Ptr(GcA))
v_res = llops.genop("getfield", [ptr_a, model.Constant('b', lltype.Void)],
resulttype=lltype.Ptr(NonGcB))
llops.genop("direct_call", [model.Constant(None, lltype.Void), v_res],
resulttype=lltype.Void)
block = model.Block([ptr_a])
block.operations.extend(llops)
block.closeblock(model.Link([], None))
link = split_block_with_keepalive(block, 1)
assert 'keepalive' in [op.opname for op in link.target.operations]
def test_nclc_ignore_functype():
# +--- inputargs: pointer_to_gc
# | v0 <- op_getfield pointer_to_gc 'c'
# +--- exitargs: v0 (i.e. a pointer to function)
# pointers to functions are 'not gc' but functions are also
# immortal so you don't need to muck around inserting keepalives
# so *they* don't die!
llops = LowLevelOpList()
ptr_a = varoftype(lltype.Ptr(GcA))
v_res = llops.genop("getfield", [ptr_a, model.Constant('c', lltype.Void)],
resulttype=GcA.c)
block = model.Block([ptr_a])
block.operations.extend(llops)
block.closeblock(model.Link([v_res], None))
assert not needs_conservative_livevar_calculation(block)
def new_wrapper(func, translator, newname=None):
# The basic idea is to produce a flow graph from scratch, using the
# help of the rtyper for the conversion of the arguments after they
# have been decoded.
bk = translator.annotator.bookkeeper
graph = bk.getdesc(func).getuniquegraph()
f = getfunctionptr(graph)
FUNCTYPE = typeOf(f).TO
newops = LowLevelOpList(translator.rtyper)
varguments = []
for var in graph.startblock.inputargs:
v = Variable(var)
v.concretetype = PyObjPtr
varguments.append(v)
wrapper_inputargs = varguments[:]
# use the rtyper to produce the conversions
inputargs = f._obj.graph.getargs()
for i in range(len(varguments)):
if FUNCTYPE.ARGS[i] != PyObjPtr:
rtyper = translator.rtyper
r_arg = rtyper.bindingrepr(inputargs[i])
# give the rtyper a chance to know which function we are wrapping
rtyper.set_wrapper_context(func)
varguments[i] = newops.convertvar(varguments[i],
r_from = pyobj_repr,
r_to = r_arg)
rtyper.set_wrapper_context(None)
vlist = [inputconst(typeOf(f), f)] + varguments
vresult = newops.genop('direct_call', vlist, resulttype=FUNCTYPE.RESULT)
if FUNCTYPE.RESULT != PyObjPtr:
# convert "result" back to a PyObject
rtyper = translator.rtyper
assert rtyper is not None, (
"needs the rtyper to perform function result conversions")
r_result = rtyper.bindingrepr(f._obj.graph.getreturnvar())
vresult = newops.convertvar(vresult,
r_from = r_result,
r_to = pyobj_repr)
# "return result"
block = Block(wrapper_inputargs)
wgraph = FunctionGraph('pyfn_' + (newname or func.func_name), block)
translator.update_call_graph(wgraph, graph, object())
translator.graphs.append(wgraph)
block.operations[:] = newops
block.closeblock(Link([vresult], wgraph.returnblock))
wgraph.getreturnvar().concretetype = PyObjPtr
checkgraph(wgraph)
# the above convertvar()s may have created and annotated new helpers
# that need to be specialized now
translator.rtyper.specialize_more_blocks()
return functionptr(FuncType([PyObjPtr] * len(wrapper_inputargs),
PyObjPtr),
wgraph.name,
graph = wgraph,
exception_policy = "CPython")
