[pypy-svn] r56725 - pypy/branch/oo-jit/pypy/jit/codegen/cli
antocuni at codespeak.net
antocuni at codespeak.net
Tue Jul 22 23:50:14 CEST 2008
Author: antocuni
Date: Tue Jul 22 23:50:13 2008
New Revision: 56725
Modified:
pypy/branch/oo-jit/pypy/jit/codegen/cli/operation.py
pypy/branch/oo-jit/pypy/jit/codegen/cli/rgenop.py
Log:
more refactoring: rename graphbuilder to methbuilder everywhere;
moreover, we now pass directly the methbuilder when constructing
Operations or when loading/storing a GenVar, instead of passing a
branchbuilder and getting the methbuilder from it
Modified: pypy/branch/oo-jit/pypy/jit/codegen/cli/operation.py
==============================================================================
--- pypy/branch/oo-jit/pypy/jit/codegen/cli/operation.py (original)
+++ pypy/branch/oo-jit/pypy/jit/codegen/cli/operation.py Tue Jul 22 23:50:13 2008
@@ -17,7 +17,7 @@
if self._gv_res is None:
restype = self.restype()
if restype is not None:
- loc = self.builder.graphbuilder.il.DeclareLocal(restype)
+ loc = self.methbuilder.il.DeclareLocal(restype)
self._gv_res = GenLocalVar(loc)
return self._gv_res
@@ -28,38 +28,38 @@
raise NotImplementedError
def storeResult(self):
- self.gv_res().store(self.builder)
+ self.gv_res().store(self.methbuilder)
class UnaryOp(Operation):
- def __init__(self, builder, gv_x):
- self.builder = builder
+ def __init__(self, methbuilder, gv_x):
+ self.methbuilder = methbuilder
self.gv_x = gv_x
def pushAllArgs(self):
- self.gv_x.load(self.builder)
+ self.gv_x.load(self.methbuilder)
def emit(self):
self.pushAllArgs()
- self.builder.graphbuilder.il.Emit(self.getOpCode())
+ self.methbuilder.il.Emit(self.getOpCode())
self.storeResult()
def getOpCode(self):
raise NotImplementedError
class BinaryOp(Operation):
- def __init__(self, builder, gv_x, gv_y):
- self.builder = builder
+ def __init__(self, methbuilder, gv_x, gv_y):
+ self.methbuilder = methbuilder
self.gv_x = gv_x
self.gv_y = gv_y
def pushAllArgs(self):
- self.gv_x.load(self.builder)
- self.gv_y.load(self.builder)
+ self.gv_x.load(self.methbuilder)
+ self.gv_y.load(self.methbuilder)
def emit(self):
self.pushAllArgs()
- self.builder.graphbuilder.il.Emit(self.getOpCode())
+ self.methbuilder.il.Emit(self.getOpCode())
self.storeResult()
def getOpCode(self):
@@ -69,25 +69,25 @@
class SameAs(UnaryOp):
def emit(self):
gv_res = self.gv_res()
- self.gv_x.load(self.builder)
- self.gv_res().store(self.builder)
+ self.gv_x.load(self.methbuilder)
+ self.gv_res().store(self.methbuilder)
class MarkLabel(Operation):
- def __init__(self, builder, label):
- self.builder = builder
+ def __init__(self, methbuilder, label):
+ self.methbuilder = methbuilder
self.label = label
def restype(self):
return None
def emit(self):
- self.builder.graphbuilder.il.MarkLabel(self.label)
+ self.methbuilder.il.MarkLabel(self.label)
class FollowLink(Operation):
- def __init__(self, builder, outputargs_gv, inputargs_gv, label):
- self.builder = builder
+ def __init__(self, methbuilder, outputargs_gv, inputargs_gv, label):
+ self.methbuilder = methbuilder
self.outputargs_gv = outputargs_gv
self.inputargs_gv = inputargs_gv
self.label = label
@@ -97,15 +97,15 @@
def emit(self):
for i in range(len(self.outputargs_gv)):
- self.outputargs_gv[i].load(self.builder)
- self.inputargs_gv[i].store(self.builder)
- self.builder.graphbuilder.il.Emit(OpCodes.Br, self.label)
+ self.outputargs_gv[i].load(self.methbuilder)
+ self.inputargs_gv[i].store(self.methbuilder)
+ self.methbuilder.il.Emit(OpCodes.Br, self.label)
class Branch(Operation):
- def __init__(self, builder, gv_cond, opcode, label):
- self.builder = builder
+ def __init__(self, methbuilder, gv_cond, opcode, label):
+ self.methbuilder = methbuilder
self.gv_cond = gv_cond
self.opcode = opcode
self.label = label
@@ -115,31 +115,31 @@
def emit(self):
if self.gv_cond is not None:
- self.gv_cond.load(self.builder)
- self.builder.graphbuilder.il.Emit(self.opcode, self.label)
+ self.gv_cond.load(self.methbuilder)
+ self.methbuilder.il.Emit(self.opcode, self.label)
class Return(Operation):
- def __init__(self, builder, gv_x):
- self.builder = builder
+ def __init__(self, methbuilder, gv_x):
+ self.methbuilder = methbuilder
self.gv_x = gv_x
def restype(self):
return None
def emit(self):
- retvar = self.builder.graphbuilder.retvar
- retlabel = self.builder.graphbuilder.retlabel
+ retvar = self.methbuilder.retvar
+ retlabel = self.methbuilder.retlabel
if self.gv_x is not None:
- self.gv_x.load(self.builder)
- self.builder.graphbuilder.il.Emit(OpCodes.Stloc, retvar)
- self.builder.graphbuilder.il.Emit(OpCodes.Br, retlabel)
+ self.gv_x.load(self.methbuilder)
+ self.methbuilder.il.Emit(OpCodes.Stloc, retvar)
+ self.methbuilder.il.Emit(OpCodes.Br, retlabel)
class Call(Operation):
- def __init__(self, builder, sigtoken, gv_fnptr, args_gv):
+ def __init__(self, methbuilder, sigtoken, gv_fnptr, args_gv):
from pypy.jit.codegen.cli.rgenop import class2type
- self.builder = builder
+ self.methbuilder = methbuilder
self.sigtoken = sigtoken
self.gv_fnptr = gv_fnptr
self.args_gv = args_gv
@@ -152,18 +152,18 @@
from pypy.jit.codegen.cli.rgenop import class2type
delegate_type = class2type(self.sigtoken.funcclass)
meth_invoke = delegate_type.GetMethod('Invoke')
- self.gv_fnptr.load(self.builder)
- self.builder.graphbuilder.il.Emit(OpCodes.Castclass, delegate_type)
+ self.gv_fnptr.load(self.methbuilder)
+ self.methbuilder.il.Emit(OpCodes.Castclass, delegate_type)
for gv_arg in self.args_gv:
- gv_arg.load(self.builder)
- self.builder.graphbuilder.il.EmitCall(OpCodes.Callvirt, meth_invoke, None)
+ gv_arg.load(self.methbuilder)
+ self.methbuilder.il.EmitCall(OpCodes.Callvirt, meth_invoke, None)
self.storeResult()
class GetField(Operation):
- def __init__(self, builder, gv_obj, fieldname):
- self.builder = builder
+ def __init__(self, methbuilder, gv_obj, fieldname):
+ self.methbuilder = methbuilder
self.gv_obj = gv_obj
clitype = gv_obj.getCliType()
self.fieldinfo = clitype.GetField(fieldname)
@@ -172,15 +172,15 @@
return self.fieldinfo.get_FieldType()
def emit(self):
- self.gv_obj.load(self.builder)
- self.builder.graphbuilder.il.Emit(OpCodes.Ldfld, self.fieldinfo)
+ self.gv_obj.load(self.methbuilder)
+ self.methbuilder.il.Emit(OpCodes.Ldfld, self.fieldinfo)
self.storeResult()
class SetField(Operation):
- def __init__(self, builder, gv_obj, gv_value, fieldname):
- self.builder = builder
+ def __init__(self, methbuilder, gv_obj, gv_value, fieldname):
+ self.methbuilder = methbuilder
self.gv_obj = gv_obj
self.gv_value = gv_value
clitype = gv_obj.getCliType()
@@ -190,14 +190,14 @@
return None
def emit(self):
- self.gv_obj.load(self.builder)
- self.gv_value.load(self.builder)
- self.builder.graphbuilder.il.Emit(OpCodes.Stfld, self.fieldinfo)
+ self.gv_obj.load(self.methbuilder)
+ self.gv_value.load(self.methbuilder)
+ self.methbuilder.il.Emit(OpCodes.Stfld, self.fieldinfo)
class DoFlexSwitch(Operation):
- def __init__(self, builder, gv_flexswitch, gv_exitswitch, args_gv):
- self.builder = builder
+ def __init__(self, methbuilder, gv_flexswitch, gv_exitswitch, args_gv):
+ self.methbuilder = methbuilder
self.gv_flexswitch = gv_flexswitch
self.gv_exitswitch = gv_exitswitch
self.args_gv = args_gv # XXX: remove duplicates
@@ -206,38 +206,38 @@
return None
def emit(self):
- gbuilder = self.builder.graphbuilder
- il = gbuilder.il
+ mbuilder = self.methbuilder
+ il = mbuilder.il
# get MethodInfo for LowLevelFlexSwitch.execute
clitype = self.gv_flexswitch.flexswitch.GetType()
meth_execute = clitype.GetMethod('execute')
# setup the correct inputargs
- manager = InputArgsManager(gbuilder, self.args_gv)
- manager.copy_from_args(self.builder)
+ manager = InputArgsManager(mbuilder, self.args_gv)
+ manager.copy_from_args(mbuilder)
# jumpto = flexswitch.execute(exitswitch, inputargs);
# goto dispatch_jump;
- self.gv_flexswitch.load(self.builder)
- self.gv_exitswitch.load(self.builder)
- il.Emit(OpCodes.Ldloc, gbuilder.inputargs_var)
+ self.gv_flexswitch.load(mbuilder)
+ self.gv_exitswitch.load(mbuilder)
+ il.Emit(OpCodes.Ldloc, mbuilder.inputargs_var)
il.Emit(OpCodes.Callvirt, meth_execute)
- il.Emit(OpCodes.Stloc, gbuilder.jumpto_var)
- il.Emit(OpCodes.Br, gbuilder.dispatch_jump_label)
+ il.Emit(OpCodes.Stloc, mbuilder.jumpto_var)
+ il.Emit(OpCodes.Br, mbuilder.dispatch_jump_label)
class InputArgsManager:
- def __init__(self, graphbuilder, args_gv):
- self.inputargs_var = graphbuilder.inputargs_var
- self.inputargs_clitype = graphbuilder.inputargs_clitype
+ def __init__(self, methbuilder, args_gv):
+ self.inputargs_var = methbuilder.inputargs_var
+ self.inputargs_clitype = methbuilder.inputargs_clitype
self.args_gv = args_gv
def basename_from_type(self, clitype):
return clitype.get_Name()
- def copy_from_args(self, builder):
- il = builder.graphbuilder.il
+ def copy_from_args(self, methbuilder):
+ il = methbuilder.methbuilder.il
inputargs_var = self.inputargs_var
inputargs_clitype = self.inputargs_clitype
counters = {}
@@ -255,15 +255,15 @@
class WriteLine(Operation):
- def __init__(self, builder, message):
- self.builder = builder
+ def __init__(self, methbuilder, message):
+ self.methbuilder = methbuilder
self.message = message
def restype(self):
return None
def emit(self):
- self.builder.graphbuilder.il.EmitWriteLine(self.message)
+ self.methbuilder.il.EmitWriteLine(self.message)
def opcode2attrname(opcode):
if opcode == 'ldc.r8 0':
@@ -327,7 +327,7 @@
if 'call' in step:
return # XXX, fix this
attrname = opcode2attrname(step)
- body.append('self.builder.graphbuilder.il.Emit(OpCodes.%s)' % attrname)
+ body.append('self.methbuilder.il.Emit(OpCodes.%s)' % attrname)
elif isinstance(step, cli_opcodes.MapException):
return # XXX, TODO
else:
Modified: pypy/branch/oo-jit/pypy/jit/codegen/cli/rgenop.py
==============================================================================
--- pypy/branch/oo-jit/pypy/jit/codegen/cli/rgenop.py (original)
+++ pypy/branch/oo-jit/pypy/jit/codegen/cli/rgenop.py Tue Jul 22 23:50:13 2008
@@ -60,20 +60,20 @@
def getCliType(self):
return self.cliType
- def load(self, builder):
+ def load(self, methbuilder):
if self.index == 0:
- builder.graphbuilder.il.Emit(OpCodes.Ldarg_0)
+ methbuilder.il.Emit(OpCodes.Ldarg_0)
elif self.index == 1:
- builder.graphbuilder.il.Emit(OpCodes.Ldarg_1)
+ methbuilder.il.Emit(OpCodes.Ldarg_1)
elif self.index == 2:
- builder.graphbuilder.il.Emit(OpCodes.Ldarg_2)
+ methbuilder.il.Emit(OpCodes.Ldarg_2)
elif self.index == 3:
- builder.graphbuilder.il.Emit(OpCodes.Ldarg_3)
+ methbuilder.il.Emit(OpCodes.Ldarg_3)
else:
- builder.graphbuilder.il.Emit(OpCodes.Ldarg, self.index)
+ methbuilder.il.Emit(OpCodes.Ldarg, self.index)
- def store(self, builder):
- builder.graphbuilder.il.Emit(OpCodes.Starg, self.index)
+ def store(self, methbuilder):
+ methbuilder.il.Emit(OpCodes.Starg, self.index)
def __repr__(self):
return "GenArgVar(%d)" % self.index
@@ -85,11 +85,11 @@
def getCliType(self):
return self.v.get_LocalType()
- def load(self, builder):
- builder.graphbuilder.il.Emit(OpCodes.Ldloc, self.v)
+ def load(self, methbuilder):
+ methbuilder.il.Emit(OpCodes.Ldloc, self.v)
- def store(self, builder):
- builder.graphbuilder.il.Emit(OpCodes.Stloc, self.v)
+ def store(self, methbuilder):
+ methbuilder.il.Emit(OpCodes.Stloc, self.v)
class IntConst(GenConst):
@@ -109,8 +109,8 @@
def getCliType(self):
return class2type(self.cliclass)
- def load(self, builder):
- builder.graphbuilder.il.Emit(OpCodes.Ldc_I4, self.value)
+ def load(self, methbuilder):
+ methbuilder.il.Emit(OpCodes.Ldc_I4, self.value)
def __repr__(self):
return "int const=%s" % self.value
@@ -130,28 +130,28 @@
def getCliType(self):
return typeof(System.Double)
- def load(self, builder):
- builder.graphbuilder.il.Emit(OpCodes.Ldc_R8, self.value)
+ def load(self, methbuilder):
+ methbuilder.il.Emit(OpCodes.Ldc_R8, self.value)
def __repr__(self):
return "float const=%s" % self.value
class BaseConst(GenConst):
- def _get_index(self, builder):
+ def _get_index(self, methbuilder):
# check whether there is already an index associated to this const
try:
- index = builder.genconsts[self]
+ index = methbuilder.genconsts[self]
except KeyError:
- index = len(builder.genconsts)
- builder.genconsts[self] = index
+ index = len(methbuilder.genconsts)
+ methbuilder.genconsts[self] = index
return index
- def _load_from_array(self, builder, index, clitype):
- builder.graphbuilder.il.Emit(OpCodes.Ldarg_0)
- builder.graphbuilder.il.Emit(OpCodes.Ldc_I4, index)
- builder.graphbuilder.il.Emit(OpCodes.Ldelem_Ref)
- builder.graphbuilder.il.Emit(OpCodes.Castclass, clitype)
+ def _load_from_array(self, methbuilder, index, clitype):
+ methbuilder.il.Emit(OpCodes.Ldarg_0)
+ methbuilder.il.Emit(OpCodes.Ldc_I4, index)
+ methbuilder.il.Emit(OpCodes.Ldelem_Ref)
+ methbuilder.il.Emit(OpCodes.Castclass, clitype)
def getobj(self):
raise NotImplementedError
@@ -170,7 +170,7 @@
def getobj(self):
return self.obj
- def load(self, builder):
+ def load(self, methbuilder):
assert False, 'XXX'
## import pdb;pdb.set_trace()
## index = self._get_index(builder)
@@ -201,14 +201,14 @@
#return ootype.ooupcast(OBJECT, self.holder)
return self.holder
- def load(self, builder):
+ def load(self, methbuilder):
holdertype = box(self.holder).GetType()
funcfield = holdertype.GetField('func')
delegatetype = self.delegatetype
- index = self._get_index(builder)
- self._load_from_array(builder, index, holdertype)
- builder.graphbuilder.il.Emit(OpCodes.Ldfld, funcfield)
- builder.graphbuilder.il.Emit(OpCodes.Castclass, delegatetype)
+ index = self._get_index(methbuilder)
+ self._load_from_array(methbuilder, index, holdertype)
+ methbuilder.il.Emit(OpCodes.Ldfld, funcfield)
+ methbuilder.il.Emit(OpCodes.Castclass, delegatetype)
@specialize.arg(1)
def revealconst(self, T):
@@ -227,9 +227,9 @@
def getobj(self):
return self.flexswitch
- def load(self, builder):
- index = self._get_index(builder)
- self._load_from_array(builder, index, self.flexswitch.GetType())
+ def load(self, methbuilder):
+ index = self._get_index(methbuilder)
+ self._load_from_array(methbuilder, index, self.flexswitch.GetType())
class Label(GenLabel):
@@ -342,7 +342,7 @@
class GraphInfo:
def __init__(self):
self.has_flexswitches = False
- self.blocks = [] # blockid -> (methodbuilder, label)
+ self.blocks = [] # blockid -> (methbuilder, label)
class MethodBuilder(GenBuilder):
@@ -506,34 +506,34 @@
class BranchBuilder(GenBuilder):
- def __init__(self, graphbuilder, label):
- self.graphbuilder = graphbuilder
- self.rgenop = graphbuilder.rgenop
+ def __init__(self, methbuilder, label):
+ self.methbuilder = methbuilder
+ self.rgenop = methbuilder.rgenop
self.label = label
self.operations = []
self.is_open = False
- self.genconsts = graphbuilder.genconsts
+ self.genconsts = methbuilder.genconsts
def start_writing(self):
self.is_open = True
def finish_and_return(self, sigtoken, gv_returnvar):
- op = ops.Return(self, gv_returnvar)
+ op = ops.Return(self.methbuilder, gv_returnvar)
self.appendop(op)
self.is_open = False
def finish_and_goto(self, outputargs_gv, target):
inputargs_gv = target.inputargs_gv
assert len(inputargs_gv) == len(outputargs_gv)
- op = ops.FollowLink(self, outputargs_gv, inputargs_gv,
- target.label)
+ op = ops.FollowLink(self.methbuilder, outputargs_gv,
+ inputargs_gv, target.label)
self.appendop(op)
self.is_open = False
@specialize.arg(1)
def genop1(self, opname, gv_arg):
opcls = ops.getopclass1(opname)
- op = opcls(self, gv_arg)
+ op = opcls(self.methbuilder, gv_arg)
self.appendop(op)
gv_res = op.gv_res()
return gv_res
@@ -541,28 +541,28 @@
@specialize.arg(1)
def genop2(self, opname, gv_arg1, gv_arg2):
opcls = ops.getopclass2(opname)
- op = opcls(self, gv_arg1, gv_arg2)
+ op = opcls(self.methbuilder, gv_arg1, gv_arg2)
self.appendop(op)
gv_res = op.gv_res()
return gv_res
def genop_call(self, sigtoken, gv_fnptr, args_gv):
- op = ops.Call(self, sigtoken, gv_fnptr, args_gv)
+ op = ops.Call(self.methbuilder, sigtoken, gv_fnptr, args_gv)
self.appendop(op)
return op.gv_res()
def genop_same_as(self, gv_x):
- op = ops.SameAs(self, gv_x)
+ op = ops.SameAs(self.methbuilder, gv_x)
self.appendop(op)
return op.gv_res()
def genop_oogetfield(self, fieldtoken, gv_obj):
- op = ops.GetField(self, gv_obj, fieldtoken)
+ op = ops.GetField(self.methbuilder, gv_obj, fieldtoken)
self.appendop(op)
return op.gv_res()
def genop_oosetfield(self, fieldtoken, gv_obj, gv_value):
- op = ops.SetField(self, gv_obj, gv_value, fieldtoken)
+ op = ops.SetField(self.methbuilder, gv_obj, gv_value, fieldtoken)
self.appendop(op)
def enter_next_block(self, args_gv):
@@ -570,28 +570,28 @@
for i in range(len(args_gv)):
gv = args_gv[i]
if isinstance(gv, GenConst) or gv in seen:
- op = ops.SameAs(self, gv)
+ op = ops.SameAs(self.methbuilder, gv)
self.appendop(op)
args_gv[i] = op.gv_res()
else:
seen[gv] = None
- label = self.graphbuilder.il.DefineLabel()
- self.appendop(ops.MarkLabel(self, label))
+ label = self.methbuilder.il.DefineLabel()
+ self.appendop(ops.MarkLabel(self.methbuilder, label))
return self.create_label(label, args_gv)
def create_label(self, label, args_gv):
- blocks = self.graphbuilder.graphinfo.blocks
+ blocks = self.methbuilder.graphinfo.blocks
blockid = len(blocks)
result = Label(blockid, label, args_gv)
- blocks.append((self.graphbuilder, result))
+ blocks.append((self.methbuilder, result))
return result
def _jump_if(self, gv_condition, opcode):
- label = self.graphbuilder.il.DefineLabel()
- op = ops.Branch(self, gv_condition, opcode, label)
+ label = self.methbuilder.il.DefineLabel()
+ op = ops.Branch(self.methbuilder, gv_condition, opcode, label)
self.appendop(op)
- branch = BranchBuilder(self.graphbuilder, label)
- self.graphbuilder.appendbranch(branch)
+ branch = BranchBuilder(self.methbuilder, label)
+ self.methbuilder.appendbranch(branch)
return branch
def jump_if_false(self, gv_condition, args_for_jump_gv):
@@ -601,18 +601,18 @@
return self._jump_if(gv_condition, OpCodes.Brtrue)
def flexswitch(self, gv_exitswitch, args_gv):
- # XXX: this code is valid only for GraphBuilder
- self.graphbuilder.setup_flexswitches()
+ # XXX: this code is valid only for Methbuilder
+ self.methbuilder.setup_flexswitches()
flexswitch = IntFlexSwitch()
- flexswitch.xxxbuilder = BranchBuilder(self.graphbuilder, self.graphbuilder.il.DefineLabel())
+ flexswitch.xxxbuilder = BranchBuilder(self.methbuilder, self.methbuilder.il.DefineLabel())
gv_flexswitch = flexswitch.gv_flexswitch
- lbl = self.graphbuilder.il.DefineLabel()
+ lbl = self.methbuilder.il.DefineLabel()
default_label = self.create_label(lbl, args_gv)
flexswitch.llflexswitch.set_default_blockid(default_label.blockid)
- op = ops.DoFlexSwitch(self, gv_flexswitch, gv_exitswitch, args_gv)
+ op = ops.DoFlexSwitch(self.methbuilder, gv_flexswitch, gv_exitswitch, args_gv)
self.appendop(op)
- default_builder = BranchBuilder(self.graphbuilder, default_label.label)
- self.graphbuilder.appendbranch(default_builder)
+ default_builder = BranchBuilder(self.methbuilder, default_label.label)
+ self.methbuilder.appendbranch(default_builder)
self.is_open = False
return flexswitch, default_builder
@@ -620,11 +620,11 @@
self.operations.append(op)
def end(self):
- self.graphbuilder.end()
+ self.methbuilder.end()
def replayops(self):
assert not self.is_open
- il = self.graphbuilder.il
+ il = self.methbuilder.il
il.MarkLabel(self.label)
for op in self.operations:
op.emit()
More information about the Pypy-commit
mailing list