def newgraph(self, sigtoken, name):
graphctx = GraphCtx(self)
# --- prologue ---
mc = self.open_mc()
entrypoint = mc.tell()
if DEBUG_TRAP:
mc.BREAKPOINT()
mc.PUSH(ebx)
mc.PUSH(esi)
mc.PUSH(edi)
mc.PUSH(ebp)
mc.MOV(ebp, esp)
graphctx.write_stack_adj(mc, initial=True)
# ^^^ pushed 5 words including the retval ( == PROLOGUE_FIXED_WORDS)
# ----------------
numargs = sigtoken # for now
inputargs_gv = []
inputoperands = []
for i in range(numargs):
inputargs_gv.append(GenVar())
ofs = WORD * (GraphCtx.PROLOGUE_FIXED_WORDS+i)
inputoperands.append(mem(ebp, ofs))
builder = Builder(self, graphctx, inputargs_gv, inputoperands)
# XXX this makes the code layout in memory a bit obscure: we have the
# prologue of the new graph somewhere in the middle of its first
# caller, all alone...
builder.set_coming_from(mc)
mc.done()
self.close_mc(mc)
#ops = [OpSameAs(v) for v in inputargs_gv]
#builder.operations.extend(ops)
#inputargs_gv = ops
return builder, IntConst(entrypoint), inputargs_gv[:]
def generate_block_code(self, final_vars_gv, final_operands=None,
renaming=True):
self.insert_keepalives()
if self.order_dependency is not None:
self.order_dependency.force_generate_code()
self.order_dependency = None
allocator = RegAllocator(self.operations)
allocator.set_final(final_vars_gv, final_operands)
if not renaming:
assert final_operands is None
final_vars_gv = allocator.varsused() # unique final vars
allocator.compute_lifetimes()
allocator.init_reg_alloc(self.inputargs_gv, self.inputoperands)
mc = self.start_mc()
allocator.generate_operations(mc)
if final_operands is not None:
allocator.generate_final_moves(final_vars_gv, final_operands)
#print 'NSTACKMAX==============>', allocator.nstackmax
self.graphctx.ensure_stack_vars(allocator.nstackmax)
del self.operations[:]
if renaming:
self.inputargs_gv = [GenVar() for v in final_vars_gv]
else:
# just keep one copy of each Variable that is alive
self.inputargs_gv = final_vars_gv
self.inputoperands = [allocator.get_operand(v) for v in final_vars_gv]
return mc
def test_genbooleq():
gv1 = GenVar()
gv2 = GenVar()
gf = rgenop.genconst(False)
gt = rgenop.genconst(True)
for b1 in [False, True]:
for b2 in [False, True]:
for rev in [False, True]:
jitstate = DummyJITState()
box = desc.genbooleq(jitstate,
rgenop.genconst(b1),
rgenop.genconst(b2),
rev)
assert box.genvar.revealconst(lltype.Bool) == (b1 == b2) ^ rev
assert not jitstate.curbuilder.operations
for b2 in [False, True]:
for rev in [False, True]:
for flip in [False, True]:
jitstate = DummyJITState()
args = [gv1, rgenop.genconst(b2), rev]
if flip:
args[0], args[1] = args[1], args[0]
box = desc.genbooleq(jitstate, *args)
should_neg = (b2 == rev)
if should_neg:
assert jitstate.curbuilder.operations == [
("bool_not", gv1, box.genvar),
]
else:
assert box.genvar == gv1
assert not jitstate.curbuilder.operations
for rev in [False, True]:
jitstate = DummyJITState()
box = desc.genbooleq(jitstate, gv1, gv2, rev)
ops = jitstate.curbuilder.operations
_, _, gvi1 = ops[0]
_, _, gvi2 = ops[1]
assert ops == [
("cast_bool_to_int", gv1, gvi1),
("cast_bool_to_int", gv2, gvi2),
(["int_eq", "int_ne"][rev], gvi1, gvi2, box.genvar),
]
def test_getboolbox():
for b1 in [False, True]:
for b2 in [False, True]:
jitstate = DummyJITState()
box = desc.getboolbox(jitstate, rgenop.genconst(b1), b2)
assert box.genvar.revealconst(lltype.Bool) == b1 ^ b2
assert not jitstate.curbuilder.operations
gv1 = GenVar()
jitstate = DummyJITState()
box = desc.getboolbox(jitstate, gv1, False)
assert box.genvar == gv1
assert not jitstate.curbuilder.operations
jitstate = DummyJITState()
box = desc.getboolbox(jitstate, gv1, True)
assert jitstate.curbuilder.operations == [
("bool_not", gv1, box.genvar),
]
def genop2(self, opname, gv_arg1, gv_arg2):
gv_res = GenVar()
self.operations.append((opname, gv_arg1, gv_arg2, gv_res))
return gv_res
def genop1(self, opname, gv_arg):
gv_res = GenVar()
self.operations.append((opname, gv_arg, gv_res))
return gv_res