def test_func_simple():
# -------------------- flowgraph building --------------------
# def f(x):
# return x+1
x = Variable("x")
x.concretetype = Signed
result = Variable("result")
result.concretetype = Signed
one = Constant(1)
one.concretetype = Signed
op = SpaceOperation("int_add", [x, one], result)
block = Block([x])
graph = FunctionGraph("f", block)
block.operations.append(op)
block.closeblock(Link([result], graph.returnblock))
graph.getreturnvar().concretetype = Signed
# -------------------- end --------------------
F = FuncType([Signed], Signed)
f = functionptr(F, "f", graph=graph)
db = LowLevelDatabase()
db.get(f)
db.complete()
dump_on_stdout(db)
S = GcStruct('testing', ('fptr', Ptr(F)))
s = malloc(S)
s.fptr = f
db = LowLevelDatabase()
db.get(s)
db.complete()
dump_on_stdout(db)
def test_func_simple():
# -------------------- flowgraph building --------------------
# def f(x):
# return x+1
x = Variable("x")
x.concretetype = Signed
result = Variable("result")
result.concretetype = Signed
one = Constant(1)
one.concretetype = Signed
op = SpaceOperation("int_add", [x, one], result)
block = Block([x])
graph = FunctionGraph("f", block)
block.operations.append(op)
block.closeblock(Link([result], graph.returnblock))
graph.getreturnvar().concretetype = Signed
# -------------------- end --------------------
F = FuncType([Signed], Signed)
f = functionptr(F, "f", graph=graph)
db = LowLevelDatabase()
db.get(f)
db.complete()
dump_on_stdout(db)
S = GcStruct('testing', ('fptr', Ptr(F)))
s = malloc(S)
s.fptr = f
db = LowLevelDatabase()
db.get(s)
db.complete()
dump_on_stdout(db)
def inputconst(reqtype, value):
"""Return a Constant with the given value, of the requested type,
which can be a Repr instance or a low-level type.
"""
if isinstance(reqtype, Repr):
value = reqtype.convert_const(value)
lltype = reqtype.lowleveltype
elif isinstance(reqtype, LowLevelType):
lltype = reqtype
else:
raise TypeError(repr(reqtype))
# Void Constants can hold any value;
# non-Void Constants must hold a correctly ll-typed value
if lltype is not Void:
try:
realtype = typeOf(value)
except (AssertionError, AttributeError):
realtype = '???'
if not isCompatibleType(realtype, lltype):
raise TyperError("inputconst(reqtype = %s, value = %s):\n"
"expected a %r,\n"
" got a %r" % (reqtype, value,
lltype, realtype))
c = Constant(value)
c.concretetype = lltype
return c
def flatten(self, S):
start = 0
if S._names and self.equivalent_substruct(S, S._names[0]):
SUBTYPE = S._flds[S._names[0]]
if isinstance(SUBTYPE, lltype.Struct):
self.flatten(SUBTYPE)
start = 1
else:
ARRAY = lltype.FixedSizeArray(SUBTYPE, 1)
self.direct_fieldptr_key[ARRAY, 'item0'] = S, S._names[0]
for name in S._names[start:]:
key = S, name
FIELDTYPE = S._flds[name]
if key in self.accessed_substructs:
self.needsubmallocs.append(key)
self.flatnames.append(key)
self.newvarstype[key] = lltype.Ptr(lltype.GcStruct('wrapper',
('data', FIELDTYPE)))
elif not isinstance(FIELDTYPE, lltype.ContainerType):
example = FIELDTYPE._defl()
constant = Constant(example)
constant.concretetype = FIELDTYPE
self.flatconstants[key] = constant
self.flatnames.append(key)
self.newvarstype[key] = FIELDTYPE
def make_const_rt_result(self, v_result, value):
newrtnode = RuntimeSpecNode(v_result, v_result.concretetype)
self.setnode(v_result, newrtnode)
if v_result.concretetype is not lltype.Void:
assert v_result.concretetype == lltype.typeOf(value)
c_value = Constant(value)
c_value.concretetype = v_result.concretetype
self.renamings[newrtnode] = c_value
def make_const_rt_result(self, v_result, value):
newrtnode = RuntimeSpecNode(v_result, v_result.concretetype)
self.setnode(v_result, newrtnode)
if v_result.concretetype is not lltype.Void:
assert v_result.concretetype == lltype.typeOf(value)
c_value = Constant(value)
c_value.concretetype = v_result.concretetype
self.renamings[newrtnode] = c_value
def replace_we_are_jitted(graph):
from rpython.rlib import jit
replacement = Constant(0)
replacement.concretetype = lltype.Signed
did_replacement = replace_symbolic(graph, jit._we_are_jitted, replacement)
if did_replacement:
constant_fold_graph(graph)
return did_replacement
def replace_we_are_jitted(graph):
from rpython.rlib import jit
replacement = Constant(0)
replacement.concretetype = lltype.Signed
did_replacement = replace_symbolic(graph, jit._we_are_jitted, replacement)
if did_replacement:
constant_fold_graph(graph)
return did_replacement
def inputdesc(reqtype, desc):
"""Return a Constant for the given desc, of the requested type,
which can only be a Repr.
"""
assert isinstance(reqtype, Repr)
value = reqtype.convert_desc(desc)
lltype = reqtype.lowleveltype
c = Constant(value)
c.concretetype = lltype
return c
def generic_exception_matching(self, afterblock, copiedexceptblock):
#XXXXX don't look: insert blocks that do exception matching
#for the cases where direct matching did not work
exc_match = Constant(
self.translator.rtyper.exceptiondata.fn_exception_match)
exc_match.concretetype = typeOf(exc_match.value)
blocks = []
for i, link in enumerate(afterblock.exits[1:]):
etype = copiedexceptblock.inputargs[0].copy()
evalue = copiedexceptblock.inputargs[1].copy()
passon_vars = self.passon_vars(i)
block = Block([etype, evalue] + passon_vars)
res = Variable()
res.concretetype = Bool
cexitcase = Constant(link.llexitcase)
cexitcase.concretetype = typeOf(cexitcase.value)
args = [exc_match, etype, cexitcase]
block.operations.append(SpaceOperation("direct_call", args, res))
block.exitswitch = res
linkargs = self.find_args_in_exceptional_case(link, link.target,
etype, evalue, afterblock,
passon_vars)
l = Link(linkargs, link.target)
l.prevblock = block
l.exitcase = True
l.llexitcase = True
block.closeblock(l)
if i > 0:
l = Link(blocks[-1].inputargs, block)
l.exitcase = False
l.llexitcase = False
blocks[-1].recloseblock(l, *blocks[-1].exits)
blocks.append(block)
blocks[-1].recloseblock(*blocks[-1].exits[:1])
blocks[-1].operations = []
blocks[-1].exitswitch = None
blocks[-1].exits[0].exitcase = None
del blocks[-1].exits[0].llexitcase
linkargs = copiedexceptblock.inputargs
copiedexceptblock.recloseblock(Link(linkargs, blocks[0]))
def generic_exception_matching(self, afterblock, copiedexceptblock):
#XXXXX don't look: insert blocks that do exception matching
#for the cases where direct matching did not work
exc_match = Constant(
self.translator.rtyper.exceptiondata.fn_exception_match)
exc_match.concretetype = typeOf(exc_match.value)
blocks = []
for i, link in enumerate(afterblock.exits[1:]):
etype = copyvar(None, copiedexceptblock.inputargs[0])
evalue = copyvar(None, copiedexceptblock.inputargs[1])
passon_vars = self.passon_vars(i)
block = Block([etype, evalue] + passon_vars)
res = Variable()
res.concretetype = Bool
cexitcase = Constant(link.llexitcase)
cexitcase.concretetype = typeOf(cexitcase.value)
args = [exc_match, etype, cexitcase]
block.operations.append(SpaceOperation("direct_call", args, res))
block.exitswitch = res
linkargs = self.find_args_in_exceptional_case(link, link.target,
etype, evalue, afterblock,
passon_vars)
l = Link(linkargs, link.target)
l.prevblock = block
l.exitcase = True
l.llexitcase = True
block.closeblock(l)
if i > 0:
l = Link(blocks[-1].inputargs, block)
l.exitcase = False
l.llexitcase = False
blocks[-1].recloseblock(l, *blocks[-1].exits)
blocks.append(block)
blocks[-1].recloseblock(*blocks[-1].exits[:1])
blocks[-1].operations = []
blocks[-1].exitswitch = None
blocks[-1].exits[0].exitcase = None
del blocks[-1].exits[0].llexitcase
linkargs = copiedexceptblock.inputargs
copiedexceptblock.recloseblock(Link(linkargs, blocks[0]))
def handle_op_malloc(self, op):
if op.result is self.v_expand_malloc:
MALLOCTYPE = op.result.concretetype.TO
typedesc = self.graphbuilder.mallocv.getmalloctypedesc(MALLOCTYPE)
virtualnode = VirtualSpecNode(typedesc, [])
self.setnode(op.result, virtualnode)
for name, FIELDTYPE in typedesc.names_and_types:
fieldnode = RuntimeSpecNode(name, FIELDTYPE)
virtualnode.fields.append(fieldnode)
c = Constant(FIELDTYPE._defl())
c.concretetype = FIELDTYPE
self.renamings[fieldnode] = c
self.v_expand_malloc = None # done
return []
else:
return self.handle_default(op)
def handle_op_malloc(self, op):
if op.result is self.v_expand_malloc:
MALLOCTYPE = op.result.concretetype.TO
typedesc = self.graphbuilder.mallocv.getmalloctypedesc(MALLOCTYPE)
virtualnode = VirtualSpecNode(typedesc, [])
self.setnode(op.result, virtualnode)
for name, FIELDTYPE in typedesc.names_and_types:
fieldnode = RuntimeSpecNode(name, FIELDTYPE)
virtualnode.fields.append(fieldnode)
c = Constant(FIELDTYPE._defl())
c.concretetype = FIELDTYPE
self.renamings[fieldnode] = c
self.v_expand_malloc = None # done
return []
else:
return self.handle_default(op)
def inputconst(reqtype, value):
"""Return a Constant with the given value, of the requested type,
which can be a Repr instance or a low-level type.
"""
if isinstance(reqtype, Repr):
value = reqtype.convert_const(value)
lltype = reqtype.lowleveltype
elif isinstance(reqtype, LowLevelType):
lltype = reqtype
else:
raise TypeError(repr(reqtype))
if not lltype._contains_value(value):
raise TyperError("inputconst(): expected a %r, got %r" %
(lltype, value))
c = Constant(value)
c.concretetype = lltype
return c
def inputconst(reqtype, value):
"""Return a Constant with the given value, of the requested type,
which can be a Repr instance or a low-level type.
"""
if isinstance(reqtype, Repr):
value = reqtype.convert_const(value)
lltype = reqtype.lowleveltype
elif isinstance(reqtype, LowLevelType):
lltype = reqtype
else:
raise TypeError(repr(reqtype))
if not lltype._contains_value(value):
raise TyperError("inputconst(): expected a %r, got %r" %
(lltype, value))
c = Constant(value)
c.concretetype = lltype
return c
def get_exc_reconstruction_block(self, typedesc):
exceptblock = self.graph.exceptblock
self.mallocv.fixup_except_block(exceptblock)
TEXC = exceptblock.inputargs[0].concretetype
TVAL = exceptblock.inputargs[1].concretetype
#
v_ignored_type = varoftype(TEXC)
v_incoming_value = varoftype(TVAL)
block = Block([v_ignored_type, v_incoming_value])
#
c_EXCTYPE = Constant(typedesc.MALLOCTYPE, lltype.Void)
v = varoftype(lltype.Ptr(typedesc.MALLOCTYPE))
c_flavor = Constant({'flavor': 'gc'}, lltype.Void)
op = SpaceOperation('malloc', [c_EXCTYPE, c_flavor], v)
block.operations.append(op)
#
for name, FIELDTYPE in typedesc.names_and_types:
EXACTPTR = lltype.Ptr(typedesc.name2subtype[name])
c_name = Constant(name)
c_name.concretetype = lltype.Void
#
v_in = varoftype(EXACTPTR)
op = SpaceOperation('cast_pointer', [v_incoming_value], v_in)
block.operations.append(op)
#
v_field = varoftype(FIELDTYPE)
op = SpaceOperation('getfield', [v_in, c_name], v_field)
block.operations.append(op)
#
v_out = varoftype(EXACTPTR)
op = SpaceOperation('cast_pointer', [v], v_out)
block.operations.append(op)
#
v0 = varoftype(lltype.Void)
op = SpaceOperation('setfield', [v_out, c_name, v_field], v0)
block.operations.append(op)
#
v_exc_value = varoftype(TVAL)
op = SpaceOperation('cast_pointer', [v], v_exc_value)
block.operations.append(op)
#
exc_type = self.mallocv.EXCTYPE_to_vtable[typedesc.MALLOCTYPE]
c_exc_type = Constant(exc_type, TEXC)
block.closeblock(Link([c_exc_type, v_exc_value], exceptblock))
return block
def get_exc_reconstruction_block(self, typedesc):
exceptblock = self.graph.exceptblock
self.mallocv.fixup_except_block(exceptblock)
TEXC = exceptblock.inputargs[0].concretetype
TVAL = exceptblock.inputargs[1].concretetype
#
v_ignored_type = varoftype(TEXC)
v_incoming_value = varoftype(TVAL)
block = Block([v_ignored_type, v_incoming_value])
#
c_EXCTYPE = Constant(typedesc.MALLOCTYPE, lltype.Void)
v = varoftype(lltype.Ptr(typedesc.MALLOCTYPE))
c_flavor = Constant({'flavor': 'gc'}, lltype.Void)
op = SpaceOperation('malloc', [c_EXCTYPE, c_flavor], v)
block.operations.append(op)
#
for name, FIELDTYPE in typedesc.names_and_types:
EXACTPTR = lltype.Ptr(typedesc.name2subtype[name])
c_name = Constant(name)
c_name.concretetype = lltype.Void
#
v_in = varoftype(EXACTPTR)
op = SpaceOperation('cast_pointer', [v_incoming_value], v_in)
block.operations.append(op)
#
v_field = varoftype(FIELDTYPE)
op = SpaceOperation('getfield', [v_in, c_name], v_field)
block.operations.append(op)
#
v_out = varoftype(EXACTPTR)
op = SpaceOperation('cast_pointer', [v], v_out)
block.operations.append(op)
#
v0 = varoftype(lltype.Void)
op = SpaceOperation('setfield', [v_out, c_name, v_field], v0)
block.operations.append(op)
#
v_exc_value = varoftype(TVAL)
op = SpaceOperation('cast_pointer', [v], v_exc_value)
block.operations.append(op)
#
exc_type = self.mallocv.EXCTYPE_to_vtable[typedesc.MALLOCTYPE]
c_exc_type = Constant(exc_type, TEXC)
block.closeblock(Link([c_exc_type, v_exc_value], exceptblock))
return block
def specialize_call(self, hop):
hop.exception_cannot_occur()
retval = Constant(hop.r_result.convert_const(hop.args_v[0].value))
retval.concretetype = hop.r_result.lowleveltype
return retval
