def test_regalloc_exitswitch_2(self):
v1 = Variable(); v1.concretetype = rclass.CLASSTYPE
v2 = Variable(); v2.concretetype = rclass.CLASSTYPE
v3 = Variable(); v3.concretetype = rclass.CLASSTYPE
v4 = Variable(); v4.concretetype = rclass.CLASSTYPE
block = Block([])
block.operations = [
SpaceOperation('res_call', [], v1),
SpaceOperation('-live-', [], None),
]
graph = FunctionGraph('f', block, v4)
exclink = Link([v2], graph.returnblock)
exclink.llexitcase = 123 # normally an exception class
exclink.last_exception = v2
exclink.last_exc_value = "unused"
block.exitswitch = c_last_exception
block.closeblock(Link([v1], graph.returnblock),
exclink)
#
self.check_assembler(graph, """
res_call -> %i0
-live-
catch_exception L1
int_return %i0
---
L1:
goto_if_exception_mismatch $123, L2
last_exception -> %i0
int_return %i0
---
L2:
reraise
""")
def transform_jump_to_except_block(self, graph, entrymap, link):
reraise = self.comes_from_last_exception(entrymap, link)
result = Variable()
result.concretetype = lltype.Void
block = Block([copyvar(None, v) for v in graph.exceptblock.inputargs])
if reraise:
block.operations = [SpaceOperation("direct_call", [self.rpyexc_reraise_ptr] + block.inputargs, result)]
else:
block.operations = [
SpaceOperation("direct_call", [self.rpyexc_raise_ptr] + block.inputargs, result),
SpaceOperation("debug_record_traceback", [], varoftype(lltype.Void)),
]
link.target = block
RETTYPE = graph.returnblock.inputargs[0].concretetype
l = Link([error_constant(RETTYPE)], graph.returnblock)
block.recloseblock(l)
def test_optimize_goto_if_not__unknownop():
v3 = Variable(); v3.concretetype = lltype.Bool
block = Block([])
block.operations = [SpaceOperation('foobar', [], v3)]
block.exitswitch = v3
block.exits = [FakeLink(False), FakeLink(True)]
assert not Transformer().optimize_goto_if_not(block)
def test_regalloc_lists(self):
v1 = Variable()
v1.concretetype = lltype.Signed
v2 = Variable()
v2.concretetype = lltype.Signed
v3 = Variable()
v3.concretetype = lltype.Signed
v4 = Variable()
v4.concretetype = lltype.Signed
v5 = Variable()
v5.concretetype = lltype.Signed
block = Block([v1])
block.operations = [
SpaceOperation('int_add', [v1, Constant(1, lltype.Signed)], v2),
SpaceOperation('rescall', [ListOfKind('int', [v1, v2])], v5),
SpaceOperation('rescall', [ListOfKind('int', [v1, v2])], v3),
]
graph = FunctionGraph('f', block, v4)
block.closeblock(Link([v3], graph.returnblock))
#
self.check_assembler(
graph, """
int_add %i0, $1 -> %i1
rescall I[%i0, %i1] -> %i2
rescall I[%i0, %i1] -> %i0
int_return %i0
""")
def test_promote_2():
v1 = varoftype(lltype.Signed)
v2 = varoftype(lltype.Signed)
op = SpaceOperation("hint", [v1, Constant({"promote": True}, lltype.Void)], v2)
returnblock = Block([varoftype(lltype.Signed)])
returnblock.operations = ()
block = Block([v1])
block.operations = [op]
block.closeblock(Link([v2], returnblock))
Transformer().optimize_block(block)
assert len(block.operations) == 2
assert block.operations[0].opname == "-live-"
assert block.operations[0].args == []
assert block.operations[1].opname == "int_guard_value"
assert block.operations[1].args == [v1]
assert block.operations[1].result is None
assert block.exits[0].args == [v1]
def test_optimize_goto_if_not__unknownop():
v3 = Variable()
v3.concretetype = lltype.Bool
block = Block([])
block.operations = [SpaceOperation('foobar', [], v3)]
block.exitswitch = v3
block.exits = [FakeLink(False), FakeLink(True)]
assert not Transformer().optimize_goto_if_not(block)
def test_promote_2():
v1 = varoftype(lltype.Signed)
v2 = varoftype(lltype.Signed)
op = SpaceOperation('hint',
[v1, Constant({'promote': True}, lltype.Void)], v2)
returnblock = Block([varoftype(lltype.Signed)])
returnblock.operations = ()
block = Block([v1])
block.operations = [op]
block.closeblock(Link([v2], returnblock))
Transformer().optimize_block(block)
assert len(block.operations) == 2
assert block.operations[0].opname == '-live-'
assert block.operations[0].args == []
assert block.operations[1].opname == 'int_guard_value'
assert block.operations[1].args == [v1]
assert block.operations[1].result is None
assert block.exits[0].args == [v1]
def naive_split_block(self, block, position):
newblock = Block([])
newblock.operations = block.operations[position:]
del block.operations[position:]
newblock.exitswitch = block.exitswitch
block.exitswitch = None
newblock.recloseblock(*block.exits)
block.recloseblock(Link([], newblock))
return newblock
def copy_block(self, block):
if block in self._copied_blocks:
return self._copied_blocks[block]
args = ([self.get_new_name(var) for var in block.inputargs] +
self.passon_vars(block))
newblock = Block(args)
self._copied_blocks[block] = newblock
newblock.operations = [self.copy_operation(op) for op in block.operations]
newblock.closeblock(*[self.copy_link(link, block) for link in block.exits])
newblock.exitswitch = self.get_new_name(block.exitswitch)
self.search_for_calls(newblock)
return newblock
def copy_block(self, block):
if block in self._copied_blocks:
return self._copied_blocks[block]
args = ([self.get_new_name(var) for var in block.inputargs] +
self.passon_vars(block))
newblock = Block(args)
self._copied_blocks[block] = newblock
newblock.operations = [self.copy_operation(op) for op in block.operations]
newblock.closeblock(*[self.copy_link(link, block) for link in block.exits])
newblock.exitswitch = self.get_new_name(block.exitswitch)
self.search_for_calls(newblock)
return newblock
def test_optimize_goto_if_not__ptr_iszero():
for opname in ['ptr_iszero', 'ptr_nonzero']:
v1 = Variable()
v3 = Variable(); v3.concretetype = lltype.Bool
block = Block([v1])
block.operations = [SpaceOperation(opname, [v1], v3)]
block.exitswitch = v3
block.exits = exits = [FakeLink(False), FakeLink(True)]
res = Transformer().optimize_goto_if_not(block)
assert res == True
assert block.operations == []
assert block.exitswitch == (opname, v1, '-live-before')
assert block.exits == exits
def test_rename_on_links():
v1 = Variable()
v2 = Variable()
v3 = Variable()
block = Block([v1])
block.operations = [SpaceOperation('cast_pointer', [v1], v2)]
block2 = Block([v3])
block.closeblock(Link([v2], block2))
Transformer().optimize_block(block)
assert block.inputargs == [v1]
assert block.operations == []
assert block.exits[0].target is block2
assert block.exits[0].args == [v1]
def test_optimize_goto_if_not__ptr_iszero():
for opname in ['ptr_iszero', 'ptr_nonzero']:
v1 = Variable()
v3 = Variable()
v3.concretetype = lltype.Bool
block = Block([v1])
block.operations = [SpaceOperation(opname, [v1], v3)]
block.exitswitch = v3
block.exits = exits = [FakeLink(False), FakeLink(True)]
res = Transformer().optimize_goto_if_not(block)
assert res == True
assert block.operations == []
assert block.exitswitch == (opname, v1, '-live-before')
assert block.exits == exits
def transform_jump_to_except_block(self, graph, entrymap, link):
reraise = self.comes_from_last_exception(entrymap, link)
result = Variable()
result.concretetype = lltype.Void
block = Block([copyvar(None, v) for v in graph.exceptblock.inputargs])
if reraise:
block.operations = [
SpaceOperation("direct_call",
[self.rpyexc_reraise_ptr] + block.inputargs,
result),
]
else:
block.operations = [
SpaceOperation("direct_call",
[self.rpyexc_raise_ptr] + block.inputargs,
result),
SpaceOperation('debug_record_traceback', [],
varoftype(lltype.Void)),
]
link.target = block
RETTYPE = graph.returnblock.inputargs[0].concretetype
l = Link([error_constant(RETTYPE)], graph.returnblock)
block.recloseblock(l)
def test_rename_on_links():
v1 = Variable()
v2 = Variable()
v2.concretetype = llmemory.Address
v3 = Variable()
block = Block([v1])
block.operations = [SpaceOperation('cast_pointer', [v1], v2)]
block2 = Block([v3])
block.closeblock(Link([v2], block2))
Transformer().optimize_block(block)
assert block.inputargs == [v1]
assert block.operations == []
assert block.exits[0].target is block2
assert block.exits[0].args == [v1]
def test_optimize_goto_if_not():
v1 = Variable()
v2 = Variable()
v3 = Variable(); v3.concretetype = lltype.Bool
sp1 = SpaceOperation('foobar', [], None)
sp2 = SpaceOperation('foobaz', [], None)
block = Block([v1, v2])
block.operations = [sp1, SpaceOperation('int_gt', [v1, v2], v3), sp2]
block.exitswitch = v3
block.exits = exits = [FakeLink(False), FakeLink(True)]
res = Transformer().optimize_goto_if_not(block)
assert res == True
assert block.operations == [sp1, sp2]
assert block.exitswitch == ('int_gt', v1, v2)
assert block.exits == exits
def test_optimize_goto_if_not__ptr_eq():
for opname in ["ptr_eq", "ptr_ne"]:
v1 = Variable()
v2 = Variable()
v3 = Variable()
v3.concretetype = lltype.Bool
block = Block([v1, v2])
block.operations = [SpaceOperation(opname, [v1, v2], v3)]
block.exitswitch = v3
block.exits = exits = [FakeLink(False), FakeLink(True)]
res = Transformer().optimize_goto_if_not(block)
assert res == True
assert block.operations == []
assert block.exitswitch == (opname, v1, v2)
assert block.exits == exits
def test_optimize_goto_if_not():
v1 = Variable()
v2 = Variable()
v3 = Variable()
v3.concretetype = lltype.Bool
sp1 = SpaceOperation('foobar', [], None)
sp2 = SpaceOperation('foobaz', [], None)
block = Block([v1, v2])
block.operations = [sp1, SpaceOperation('int_gt', [v1, v2], v3), sp2]
block.exitswitch = v3
block.exits = exits = [FakeLink(False), FakeLink(True)]
res = Transformer().optimize_goto_if_not(block)
assert res == True
assert block.operations == [sp1, sp2]
assert block.exitswitch == ('int_gt', v1, v2)
assert block.exits == exits
def test_optimize_goto_if_not__exit():
# this case occurs in practice, e.g. with RPython code like:
# return bool(p) and p.somefield > 0
v1 = Variable()
v2 = Variable()
v3 = Variable(); v3.concretetype = lltype.Bool
block = Block([v1, v2])
block.operations = [SpaceOperation('int_gt', [v1, v2], v3)]
block.exitswitch = v3
block.exits = exits = [FakeLink(False), FakeLink(True)]
block.exits[1].args = [v3]
res = Transformer().optimize_goto_if_not(block)
assert res == True
assert block.operations == []
assert block.exitswitch == ('int_gt', v1, v2)
assert block.exits == exits
assert exits[1].args == [const(True)]
def test_regalloc_call(self):
v1 = Variable(); v1.concretetype = lltype.Signed
v2 = Variable(); v2.concretetype = lltype.Signed
v3 = Variable(); v3.concretetype = lltype.Signed
v4 = Variable(); v4.concretetype = lltype.Signed
block = Block([v1])
block.operations = [
SpaceOperation('int_add', [v1, Constant(1, lltype.Signed)], v2),
SpaceOperation('rescall', [ListOfKind('int', [v1, v2])], v3),
]
graph = FunctionGraph('f', block, v4)
block.closeblock(Link([v3], graph.returnblock))
#
self.check_assembler(graph, """
int_add %i0, $1 -> %i1
rescall I[%i0, %i1] -> %i0
int_return %i0
""")
def test_optimize_goto_if_not__exit():
# this case occurs in practice, e.g. with RPython code like:
# return bool(p) and p.somefield > 0
v1 = Variable()
v2 = Variable()
v3 = Variable()
v3.concretetype = lltype.Bool
block = Block([v1, v2])
block.operations = [SpaceOperation('int_gt', [v1, v2], v3)]
block.exitswitch = v3
block.exits = exits = [FakeLink(False), FakeLink(True)]
block.exits[1].args = [v3]
res = Transformer().optimize_goto_if_not(block)
assert res == True
assert block.operations == []
assert block.exitswitch == ('int_gt', v1, v2)
assert block.exits == exits
assert exits[1].args == [const(True)]
def test_regalloc_exitswitch_2(self):
v1 = Variable()
v1.concretetype = rclass.CLASSTYPE
v2 = Variable()
v2.concretetype = rclass.CLASSTYPE
v3 = Variable()
v3.concretetype = rclass.CLASSTYPE
v4 = Variable()
v4.concretetype = rclass.CLASSTYPE
block = Block([])
block.operations = [
SpaceOperation('res_call', [], v1),
SpaceOperation('-live-', [], None),
]
graph = FunctionGraph('f', block, v4)
exclink = Link([v2], graph.returnblock)
exclink.llexitcase = 123 # normally an exception class
exclink.last_exception = v2
exclink.last_exc_value = "unused"
block.exitswitch = c_last_exception
block.closeblock(Link([v1], graph.returnblock), exclink)
#
self.check_assembler(
graph, """
res_call -> %i0
-live-
catch_exception L1
int_return %i0
---
L1:
goto_if_exception_mismatch $123, L2
last_exception -> %i0
int_return %i0
---
L2:
reraise
""")
def tweak_generator_body_graph(Entry, graph):
# First, always run simplify_graph in order to reduce the number of
# variables passed around
simplify_graph(graph)
#
assert graph.startblock.operations[0].opname == 'generator_mark'
graph.startblock.operations.pop(0)
#
insert_empty_startblock(None, graph)
_insert_reads(graph.startblock, Entry.varnames)
Entry.block = graph.startblock
#
mappings = [Entry]
#
stopblock = Block([])
v0 = Variable()
v1 = Variable()
stopblock.operations = [
SpaceOperation('simple_call', [Constant(StopIteration)], v0),
SpaceOperation('type', [v0], v1),
]
stopblock.closeblock(Link([v1, v0], graph.exceptblock))
#
for block in list(graph.iterblocks()):
for exit in block.exits:
if exit.target is graph.returnblock:
exit.args = []
exit.target = stopblock
assert block is not stopblock
for index in range(len(block.operations) - 1, -1, -1):
op = block.operations[index]
if op.opname == 'yield':
[v_yielded_value] = op.args
del block.operations[index]
newlink = split_block(None, block, index)
newblock = newlink.target
#
class Resume(AbstractPosition):
_immutable_ = True
block = newblock
Resume.__name__ = 'Resume%d' % len(mappings)
mappings.append(Resume)
varnames = get_variable_names(newlink.args)
#
_insert_reads(newblock, varnames)
#
v_resume = Variable('resume')
block.operations.append(
SpaceOperation('simple_call', [Constant(Resume)],
v_resume))
for i, name in enumerate(varnames):
block.operations.append(
SpaceOperation(
'setattr',
[v_resume,
Constant(name), newlink.args[i]], Variable()))
v_pair = Variable('pair')
block.operations.append(
SpaceOperation('newtuple', [v_resume, v_yielded_value],
v_pair))
newlink.args = [v_pair]
newlink.target = graph.returnblock
#
regular_entry_block = Block([Variable('entry')])
block = regular_entry_block
for Resume in mappings:
v_check = Variable()
block.operations.append(
SpaceOperation(
'simple_call',
[Constant(isinstance), block.inputargs[0],
Constant(Resume)], v_check))
block.exitswitch = v_check
link1 = Link([block.inputargs[0]], Resume.block)
link1.exitcase = True
nextblock = Block([Variable('entry')])
link2 = Link([block.inputargs[0]], nextblock)
link2.exitcase = False
block.closeblock(link1, link2)
block = nextblock
block.closeblock(
Link([
Constant(AssertionError),
Constant(AssertionError("bad generator class"))
], graph.exceptblock))
graph.startblock = regular_entry_block
graph.signature = Signature(['entry'])
graph.defaults = ()
checkgraph(graph)
eliminate_empty_blocks(graph)
def gen_exc_check(self, block, returnblock, normalafterblock=None):
# var_exc_occured = Variable()
# var_exc_occured.concretetype = lltype.Bool
# block.operations.append(SpaceOperation("safe_call", [self.rpyexc_occured_ptr], var_exc_occured))
llops = rtyper.LowLevelOpList(None)
spaceop = block.operations[-1]
alloc_shortcut = self.check_for_alloc_shortcut(spaceop)
# XXX: does alloc_shortcut make sense also for ootype?
if alloc_shortcut:
T = spaceop.result.concretetype
var_no_exc = self.gen_nonnull(spaceop.result, llops)
else:
v_exc_type = self.gen_getfield("exc_type", llops)
var_no_exc = self.gen_isnull(v_exc_type, llops)
block.operations.extend(llops)
block.exitswitch = var_no_exc
# exception occurred case
b = Block([])
b.operations = [SpaceOperation("debug_record_traceback", [], varoftype(lltype.Void))]
l = Link([error_constant(returnblock.inputargs[0].concretetype)], returnblock)
b.closeblock(l)
l = Link([], b)
l.exitcase = l.llexitcase = False
# non-exception case
l0 = block.exits[0]
l0.exitcase = l0.llexitcase = True
block.recloseblock(l0, l)
insert_zeroing_op = False
if spaceop.opname == "malloc":
flavor = spaceop.args[1].value["flavor"]
if flavor == "gc":
insert_zeroing_op = True
elif spaceop.opname == "malloc_nonmovable":
# xxx we cannot insert zero_gc_pointers_inside after
# malloc_nonmovable, because it can return null. For now
# we simply always force the zero=True flag on
# malloc_nonmovable.
c_flags = spaceop.args[1]
c_flags.value = c_flags.value.copy()
spaceop.args[1].value["zero"] = True
# NB. when inserting more special-cases here, keep in mind that
# you also need to list the opnames in transform_block()
# (see "special cases")
if insert_zeroing_op:
if normalafterblock is None:
normalafterblock = insert_empty_block(None, l0)
v_result = spaceop.result
if v_result in l0.args:
result_i = l0.args.index(v_result)
v_result_after = normalafterblock.inputargs[result_i]
else:
v_result_after = copyvar(None, v_result)
l0.args.append(v_result)
normalafterblock.inputargs.append(v_result_after)
normalafterblock.operations.insert(
0, SpaceOperation("zero_gc_pointers_inside", [v_result_after], varoftype(lltype.Void))
)
def gen_exc_check(self, block, returnblock, normalafterblock=None):
#var_exc_occured = Variable()
#var_exc_occured.concretetype = lltype.Bool
#block.operations.append(SpaceOperation("safe_call", [self.rpyexc_occured_ptr], var_exc_occured))
llops = rtyper.LowLevelOpList(None)
spaceop = block.operations[-1]
alloc_shortcut = self.check_for_alloc_shortcut(spaceop)
# XXX: does alloc_shortcut make sense also for ootype?
if alloc_shortcut:
T = spaceop.result.concretetype
var_no_exc = self.gen_nonnull(spaceop.result, llops)
else:
v_exc_type = self.gen_getfield('exc_type', llops)
var_no_exc = self.gen_isnull(v_exc_type, llops)
block.operations.extend(llops)
block.exitswitch = var_no_exc
#exception occurred case
b = Block([])
b.operations = [SpaceOperation('debug_record_traceback', [],
varoftype(lltype.Void))]
l = Link([error_constant(returnblock.inputargs[0].concretetype)], returnblock)
b.closeblock(l)
l = Link([], b)
l.exitcase = l.llexitcase = False
#non-exception case
l0 = block.exits[0]
l0.exitcase = l0.llexitcase = True
block.recloseblock(l0, l)
insert_zeroing_op = False
# XXX this is not right. it also inserts zero_gc_pointers_inside
# XXX on a path that malloc_nonmovable returns null, but does not raise
# XXX which might end up with a segfault. But we don't have such gc now
if spaceop.opname == 'malloc' or spaceop.opname == 'malloc_nonmovable':
flavor = spaceop.args[1].value['flavor']
if flavor == 'gc':
insert_zeroing_op = True
if insert_zeroing_op:
if normalafterblock is None:
normalafterblock = insert_empty_block(None, l0)
v_result = spaceop.result
if v_result in l0.args:
result_i = l0.args.index(v_result)
v_result_after = normalafterblock.inputargs[result_i]
else:
v_result_after = copyvar(None, v_result)
l0.args.append(v_result)
normalafterblock.inputargs.append(v_result_after)
normalafterblock.operations.insert(
0, SpaceOperation('zero_gc_pointers_inside',
[v_result_after],
varoftype(lltype.Void)))
if self.always_exc_clear:
# insert code that clears the exception even in the non-exceptional
# case... this is a hint for the JIT, but pointless otherwise
if normalafterblock is None:
normalafterblock = insert_empty_block(None, l0)
llops = rtyper.LowLevelOpList(None)
self.gen_setfield('exc_value', self.c_null_evalue, llops)
self.gen_setfield('exc_type', self.c_null_etype, llops)
normalafterblock.operations[:0] = llops
def tweak_generator_body_graph(Entry, graph):
# First, always run simplify_graph in order to reduce the number of
# variables passed around
simplify_graph(graph)
#
assert graph.startblock.operations[0].opname == 'generator_mark'
graph.startblock.operations.pop(0)
#
insert_empty_startblock(None, graph)
_insert_reads(graph.startblock, Entry.varnames)
Entry.block = graph.startblock
#
mappings = [Entry]
#
stopblock = Block([])
v0 = Variable(); v1 = Variable()
stopblock.operations = [
SpaceOperation('simple_call', [Constant(StopIteration)], v0),
SpaceOperation('type', [v0], v1),
]
stopblock.closeblock(Link([v1, v0], graph.exceptblock))
#
for block in list(graph.iterblocks()):
for exit in block.exits:
if exit.target is graph.returnblock:
exit.args = []
exit.target = stopblock
assert block is not stopblock
for index in range(len(block.operations)-1, -1, -1):
op = block.operations[index]
if op.opname == 'yield':
[v_yielded_value] = op.args
del block.operations[index]
newlink = split_block(None, block, index)
newblock = newlink.target
#
class Resume(AbstractPosition):
_immutable_ = True
block = newblock
Resume.__name__ = 'Resume%d' % len(mappings)
mappings.append(Resume)
varnames = get_variable_names(newlink.args)
#
_insert_reads(newblock, varnames)
#
v_resume = Variable('resume')
block.operations.append(
SpaceOperation('simple_call', [Constant(Resume)],
v_resume))
for i, name in enumerate(varnames):
block.operations.append(
SpaceOperation('setattr', [v_resume, Constant(name),
newlink.args[i]],
Variable()))
v_pair = Variable('pair')
block.operations.append(
SpaceOperation('newtuple', [v_resume, v_yielded_value],
v_pair))
newlink.args = [v_pair]
newlink.target = graph.returnblock
#
regular_entry_block = Block([Variable('entry')])
block = regular_entry_block
for Resume in mappings:
v_check = Variable()
block.operations.append(
SpaceOperation('simple_call', [Constant(isinstance),
block.inputargs[0],
Constant(Resume)],
v_check))
block.exitswitch = v_check
link1 = Link([block.inputargs[0]], Resume.block)
link1.exitcase = True
nextblock = Block([Variable('entry')])
link2 = Link([block.inputargs[0]], nextblock)
link2.exitcase = False
block.closeblock(link1, link2)
block = nextblock
block.closeblock(Link([Constant(AssertionError),
Constant(AssertionError("bad generator class"))],
graph.exceptblock))
graph.startblock = regular_entry_block
graph.signature = Signature(['entry'])
graph.defaults = ()
checkgraph(graph)
eliminate_empty_blocks(graph)
def gen_exc_check(self, block, returnblock, normalafterblock=None):
#var_exc_occured = Variable()
#var_exc_occured.concretetype = lltype.Bool
#block.operations.append(SpaceOperation("safe_call", [self.rpyexc_occured_ptr], var_exc_occured))
llops = rtyper.LowLevelOpList(None)
spaceop = block.operations[-1]
alloc_shortcut = self.check_for_alloc_shortcut(spaceop)
# XXX: does alloc_shortcut make sense also for ootype?
if alloc_shortcut:
T = spaceop.result.concretetype
var_no_exc = self.gen_nonnull(spaceop.result, llops)
else:
v_exc_type = self.gen_getfield('exc_type', llops)
var_no_exc = self.gen_isnull(v_exc_type, llops)
block.operations.extend(llops)
block.exitswitch = var_no_exc
#exception occurred case
b = Block([])
b.operations = [
SpaceOperation('debug_record_traceback', [],
varoftype(lltype.Void))
]
l = Link([error_constant(returnblock.inputargs[0].concretetype)],
returnblock)
b.closeblock(l)
l = Link([], b)
l.exitcase = l.llexitcase = False
#non-exception case
l0 = block.exits[0]
l0.exitcase = l0.llexitcase = True
block.recloseblock(l0, l)
insert_zeroing_op = False
# XXX this is not right. it also inserts zero_gc_pointers_inside
# XXX on a path that malloc_nonmovable returns null, but does not raise
# XXX which might end up with a segfault. But we don't have such gc now
if spaceop.opname == 'malloc' or spaceop.opname == 'malloc_nonmovable':
flavor = spaceop.args[1].value['flavor']
if flavor == 'gc':
insert_zeroing_op = True
if insert_zeroing_op:
if normalafterblock is None:
normalafterblock = insert_empty_block(None, l0)
v_result = spaceop.result
if v_result in l0.args:
result_i = l0.args.index(v_result)
v_result_after = normalafterblock.inputargs[result_i]
else:
v_result_after = copyvar(None, v_result)
l0.args.append(v_result)
normalafterblock.inputargs.append(v_result_after)
normalafterblock.operations.insert(
0,
SpaceOperation('zero_gc_pointers_inside', [v_result_after],
varoftype(lltype.Void)))
if self.always_exc_clear:
# insert code that clears the exception even in the non-exceptional
# case... this is a hint for the JIT, but pointless otherwise
if normalafterblock is None:
normalafterblock = insert_empty_block(None, l0)
llops = rtyper.LowLevelOpList(None)
self.gen_setfield('exc_value', self.c_null_evalue, llops)
self.gen_setfield('exc_type', self.c_null_etype, llops)
normalafterblock.operations[:0] = llops
def gen_exc_check(self, block, returnblock, normalafterblock=None):
#var_exc_occured = Variable()
#var_exc_occured.concretetype = lltype.Bool
#block.operations.append(SpaceOperation("safe_call", [self.rpyexc_occured_ptr], var_exc_occured))
llops = rtyper.LowLevelOpList(None)
spaceop = block.operations[-1]
alloc_shortcut = self.check_for_alloc_shortcut(spaceop)
# XXX: does alloc_shortcut make sense also for ootype?
if alloc_shortcut:
T = spaceop.result.concretetype
var_no_exc = self.gen_nonnull(spaceop.result, llops)
else:
v_exc_type = self.gen_getfield('exc_type', llops)
var_no_exc = self.gen_isnull(v_exc_type, llops)
block.operations.extend(llops)
block.exitswitch = var_no_exc
#exception occurred case
b = Block([])
b.operations = [
SpaceOperation('debug_record_traceback', [],
varoftype(lltype.Void))
]
l = Link([error_constant(returnblock.inputargs[0].concretetype)],
returnblock)
b.closeblock(l)
l = Link([], b)
l.exitcase = l.llexitcase = False
#non-exception case
l0 = block.exits[0]
l0.exitcase = l0.llexitcase = True
block.recloseblock(l0, l)
insert_zeroing_op = False
if spaceop.opname == 'malloc':
flavor = spaceop.args[1].value['flavor']
if flavor == 'gc':
insert_zeroing_op = True
elif spaceop.opname == 'malloc_nonmovable':
# xxx we cannot insert zero_gc_pointers_inside after
# malloc_nonmovable, because it can return null. For now
# we simply always force the zero=True flag on
# malloc_nonmovable.
c_flags = spaceop.args[1]
c_flags.value = c_flags.value.copy()
spaceop.args[1].value['zero'] = True
# NB. when inserting more special-cases here, keep in mind that
# you also need to list the opnames in transform_block()
# (see "special cases")
if insert_zeroing_op:
if normalafterblock is None:
normalafterblock = insert_empty_block(None, l0)
v_result = spaceop.result
if v_result in l0.args:
result_i = l0.args.index(v_result)
v_result_after = normalafterblock.inputargs[result_i]
else:
v_result_after = copyvar(None, v_result)
l0.args.append(v_result)
normalafterblock.inputargs.append(v_result_after)
normalafterblock.operations.insert(
0,
SpaceOperation('zero_gc_pointers_inside', [v_result_after],
varoftype(lltype.Void)))
def build_pytypeobject(r_inst):
rtyper = r_inst.rtyper
cache = rtyper.classdef_to_pytypeobject
try:
return cache[r_inst.classdef]
except KeyError:
for parentdef in r_inst.classdef.getmro():
cpytype = parentdef._cpy_exported_type_
if cpytype is not None:
break
else:
# for classes that cannot be exported at all
return lltype.nullptr(lltype.PyObject)
from pypy.rpython.lltypesystem.rclass import CPYOBJECTPTR
from pypy.rpython.rtyper import LowLevelOpList
typetype = lltype.pyobjectptr(type)
# XXX default tp_new should go away
# make the graph of tp_new manually
v1 = Variable('tp'); v1.concretetype = lltype.Ptr(PY_TYPE_OBJECT)
v2 = Variable('args'); v2.concretetype = PyObjPtr
v3 = Variable('kwds'); v3.concretetype = PyObjPtr
block = Block([v1, v2, v3])
llops = LowLevelOpList(None)
v4 = r_inst.new_instance(llops, v_cpytype = v1)
v5 = llops.genop('cast_pointer', [v4], resulttype = PyObjPtr)
block.operations = list(llops)
tp_new_graph = FunctionGraph('ll_tp_new', block)
block.closeblock(Link([v5], tp_new_graph.returnblock))
tp_new_graph.getreturnvar().concretetype = v5.concretetype
# build the PyTypeObject structure
pytypeobj = lltype.malloc(PY_TYPE_OBJECT, flavor='cpy',
extra_args=(typetype,))
name = cpytype.name
T = lltype.FixedSizeArray(lltype.Char, len(name)+1)
p = lltype.malloc(T, immortal=True)
for i in range(len(name)):
p[i] = name[i]
p[len(name)] = '\x00'
pytypeobj.c_tp_name = lltype.direct_arrayitems(p)
pytypeobj.c_tp_basicsize = llmemory.sizeof(r_inst.lowleveltype.TO)
if cpytype.subclassable and False: # XXX deallocation of subclass object segfaults!
pytypeobj.c_tp_flags = CDefinedIntSymbolic('''(Py_TPFLAGS_DEFAULT |
Py_TPFLAGS_CHECKTYPES | Py_TPFLAGS_BASETYPE)''')
else:
pytypeobj.c_tp_flags = CDefinedIntSymbolic('''(Py_TPFLAGS_DEFAULT |
Py_TPFLAGS_CHECKTYPES)''')
pytypeobj.c_tp_new = rtyper.type_system.getcallable(tp_new_graph)
pytypeobj.c_tp_dealloc = rtyper.annotate_helper_fn(ll_tp_dealloc,
[PyObjPtr])
pytypeobj.c_tp_as_number = lltype.malloc(PyNumberMethods, immortal=True)
pytypeobj.c_tp_as_sequence = lltype.malloc(PySequenceMethods, immortal=True)
pytypeobj.c_tp_as_mapping = lltype.malloc(PyMappingMethods, immortal=True)
result = lltype.cast_pointer(PyObjPtr, pytypeobj)
# the llsetup function that will store the 'objects' into the
# type's tp_dict
Py_TPFLAGS_HEAPTYPE = CDefinedIntSymbolic('Py_TPFLAGS_HEAPTYPE')
if cpytype.objects:
objects = [(lltype.pyobjectptr(name), value)
for name, value in cpytype.objects.items() if name != '__new__']
if '__new__' in cpytype.objects:
new = cpytype.objects['__new__']._obj.value
objects.append((lltype.pyobjectptr('__new__'),
lltype.pyobjectptr(staticmethod(new))))
def ll_type_setup(p):
tp = lltype.cast_pointer(lltype.Ptr(PY_TYPE_OBJECT), p)
old_flags = tp.c_tp_flags
tp.c_tp_flags |= Py_TPFLAGS_HEAPTYPE
for name, value in objects:
llop.setattr(PyObjPtr, tp, name, value)
tp.c_tp_flags = old_flags
result._obj.setup_fnptr = rtyper.annotate_helper_fn(ll_type_setup,
[PyObjPtr])
cache[r_inst.classdef] = result
return result
