[pypy-commit] pypy kill-ootype: Remove rpython.jit.backend.cli
rlamy
noreply at buildbot.pypy.org
Sun Jul 7 14:22:22 CEST 2013
Author: Ronan Lamy <ronan.lamy at gmail.com>
Branch: kill-ootype
Changeset: r65250:f412e1a0c029
Date: 2013-07-07 05:13 +0200
http://bitbucket.org/pypy/pypy/changeset/f412e1a0c029/
Log: Remove rpython.jit.backend.cli
diff --git a/rpython/jit/backend/cli/README.txt b/rpython/jit/backend/cli/README.txt
deleted file mode 100644
--- a/rpython/jit/backend/cli/README.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-What you need to run CLI jit tests
-==================================
-
-Translated tests
------------------
-
-Recent versions of mono contains a bug that prevents jit tests to run correctly:
-http://bugzilla.novell.com/show_bug.cgi?id=474718
-
-To run them, you either need:
-
- - an old version of mono (1.9 is known to work; probably versions up to 2.2
- works too but I'm not sure)
-
- - to run mono with -O=-branch; something like alias mono="mono -O=-branch"
- should work, but I never tried
-
-
-Direct tests
-------------
-
-You need Pythonnet: instructions on how to install it are here:
-http://codespeak.net/pypy/dist/pypy/doc/cli-backend.html
diff --git a/rpython/jit/backend/cli/__init__.py b/rpython/jit/backend/cli/__init__.py
deleted file mode 100644
diff --git a/rpython/jit/backend/cli/method.py b/rpython/jit/backend/cli/method.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/method.py
+++ /dev/null
@@ -1,863 +0,0 @@
-import py
-import os
-from rpython.rlib.debug import debug_start, debug_stop
-from rpython.tool.pairtype import extendabletype
-from rpython.rtyper.ootypesystem import ootype
-from rpython.translator.cli import dotnet
-from rpython.translator.cli.dotnet import CLR
-from rpython.translator.cli import opcodes
-from rpython.jit.metainterp import history
-from rpython.jit.metainterp.history import (AbstractValue, Const, ConstInt, ConstFloat,
- ConstObj, BoxInt, LoopToken)
-from rpython.jit.metainterp.resoperation import rop, opname
-from rpython.jit.metainterp.typesystem import oohelper
-from rpython.jit.backend.cli import runner
-from rpython.jit.backend.cli.methodfactory import get_method_wrapper
-
-System = CLR.System
-OpCodes = System.Reflection.Emit.OpCodes
-LoopDelegate = CLR.pypy.runtime.LoopDelegate
-DelegateHolder = CLR.pypy.runtime.DelegateHolder
-InputArgs = CLR.pypy.runtime.InputArgs
-ListOfVoid = CLR.pypy.runtime.ListOfVoid
-Utils = CLR.pypy.runtime.Utils
-
-cVoid = ootype.nullruntimeclass
-
-class __extend__(AbstractValue):
- __metaclass__ = extendabletype
-
- def getCliType(self, meth):
- if self in meth.box2type:
- return meth.box2type[self]
-
- if self.type == history.INT:
- return dotnet.typeof(System.Int32)
- elif self.type == history.FLOAT:
- return dotnet.typeof(System.Double)
- elif self.type == history.REF:
- return dotnet.typeof(System.Object)
- else:
- assert False, 'Unknown type: %s' % self.type
-
- def load(self, meth):
- v = meth.var_for_box(self)
- meth.il.Emit(OpCodes.Ldloc, v)
-
- def store(self, meth):
- v = meth.var_for_box(self)
- meth.il.Emit(OpCodes.Stloc, v)
-
-
-class __extend__(Const):
- __metaclass__ = extendabletype
-
- def load(self, meth):
- index = meth.get_index_for_constant(self)
- meth.av_consts.load(meth)
- meth.il.Emit(OpCodes.Ldc_I4, index)
- meth.il.Emit(OpCodes.Ldelem_Ref)
-
- def store(self, meth):
- assert False, 'cannot store() to Constant'
-
- def get_cliobj(self):
- return dotnet.cast_to_native_object(self.getref_base())
-
-class __extend__(ConstInt):
- __metaclass__ = extendabletype
-
- def load(self, meth):
- meth.il.Emit(OpCodes.Ldc_I4, self.value)
-
-
-class __extend__(ConstFloat):
- __metaclass__ = extendabletype
-
- def load(self, meth):
- # we cannot invoke il.Emit(Ldc_R8, self.value) directly because
- # pythonnet would select the wrong overload. The C# version works
- # arond it
- Utils.Emit_Ldc_R8(meth.il, self.value);
-
-
-class ConstFunction(Const):
-
- def __init__(self, name):
- self.name = name
- self.holder = DelegateHolder()
-
- def get_cliobj(self):
- return dotnet.cliupcast(self.holder, System.Object)
-
- def load(self, meth):
- holdertype = self.holder.GetType()
- funcfield = holdertype.GetField('func')
- Const.load(self, meth)
- meth.il.Emit(OpCodes.Castclass, holdertype)
- meth.il.Emit(OpCodes.Ldfld, funcfield)
- meth.il.Emit(OpCodes.Castclass, dotnet.typeof(LoopDelegate))
-
- def _getrepr_(self):
- return '<ConstFunction %s>' % self.name
-
- def __hash__(self):
- return hash(self.holder)
-
-
-class MethodArgument(AbstractValue):
- def __init__(self, index, cliType):
- self.index = index
- self.cliType = cliType
-
- def getCliType(self, meth):
- return self.cliType
-
- def load(self, meth):
- if self.index == 0:
- meth.il.Emit(OpCodes.Ldarg_0)
- elif self.index == 1:
- meth.il.Emit(OpCodes.Ldarg_1)
- elif self.index == 2:
- meth.il.Emit(OpCodes.Ldarg_2)
- elif self.index == 3:
- meth.il.Emit(OpCodes.Ldarg_3)
- else:
- meth.il.Emit(OpCodes.Ldarg, self.index)
-
- def store(self, meth):
- meth.il.Emit(OpCodes.Starg, self.index)
-
- def __repr__(self):
- return "MethodArgument(%d)" % self.index
-
-
-class Method(object):
-
- operations = [] # overwritten at the end of the module
- debug = False
- tailcall = True
- nocast = True
-
- def __init__(self, cpu, cliloop):
- self.setoptions()
- self.cpu = cpu
- self.name = cliloop.get_fresh_cli_name()
- self.cliloop = cliloop
- self.boxes = {} # box --> local var
- self.branches = []
- self.branchlabels = []
- self.consts = {} # object --> index
- self.meth_wrapper = self._get_meth_wrapper()
- self.il = self.meth_wrapper.get_il_generator()
- self.av_consts = MethodArgument(0, System.Type.GetType("System.Object[]"))
- t_InputArgs = dotnet.typeof(InputArgs)
- self.av_inputargs = MethodArgument(1,t_InputArgs )
- self.av_ovf_flag = BoxInt()
- self.exc_value_field = t_InputArgs.GetField('exc_value')
- if cpu.rtyper:
- self.av_OverflowError = ConstObj(ootype.cast_to_object(cpu.ll_ovf_exc))
- self.av_ZeroDivisionError = ConstObj(ootype.cast_to_object(cpu.ll_zero_exc))
- else:
- self.av_OverflowError = None
- self.av_ZeroDivisionError = None
- self.box2type = {}
-
- def compile(self):
- # ----
- debug_start('jit-backend-emit_ops')
- if self.nocast:
- self.compute_types()
- self.emit_load_inputargs()
- self.emit_preamble()
- self.emit_operations(self.cliloop.operations)
- self.emit_branches()
- self.emit_end()
- debug_stop('jit-backend-emit_ops')
- # ----
- debug_start('jit-backend-finish_code')
- res = self.finish_code()
- debug_stop('jit-backend-finish_code')
- return res
-
- def _parseopt(self, text):
- text = text.lower()
- if text[0] == '-':
- return text[1:], False
- elif text[0] == '+':
- return text[1:], True
- else:
- return text, True
-
- def setoptions(self):
- opts = os.environ.get('PYPYJITOPT')
- if not opts:
- return
- parts = opts.split(' ')
- for part in parts:
- name, value = self._parseopt(part)
- if name == 'debug':
- self.debug = value
- elif name == 'tailcall':
- self.tailcall = value
- elif name == 'nocast':
- self.nocast = value
- else:
- os.write(2, 'Warning: invalid option name: %s\n' % name)
-
- def _collect_types(self, operations, box2classes):
- for op in operations:
- if op.getopnum() in (rop.GETFIELD_GC, rop.SETFIELD_GC):
- box = op.args[0]
- descr = op.getdescr()
- assert isinstance(descr, runner.FieldDescr)
- box2classes.setdefault(box, []).append(descr.selfclass)
- if op in self.cliloop.guard2ops:
- _, suboperations = self.cliloop.guard2ops[op]
- self._collect_types(suboperations, box2classes)
-
- def compute_types(self):
- box2classes = {} # box --> [ootype.Class]
- self._collect_types(self.cliloop.operations, box2classes)
- for box, classes in box2classes.iteritems():
- cls = classes[0]
- for cls2 in classes[1:]:
- if ootype.subclassof(cls, cls2):
- cls = cls2
- else:
- assert ootype.subclassof(cls2, cls)
- self.box2type[box] = dotnet.class2type(cls)
-
- def finish_code(self):
- delegatetype = dotnet.typeof(LoopDelegate)
- # initialize the array of genconsts
- consts = dotnet.new_array(System.Object, len(self.consts))
- for av_const, i in self.consts.iteritems():
- consts[i] = av_const.get_cliobj()
- # build the delegate
- func = self.meth_wrapper.create_delegate(delegatetype, consts)
- return dotnet.clidowncast(func, LoopDelegate)
-
- def _get_meth_wrapper(self):
- restype = dotnet.class2type(cVoid)
- args = self._get_args_array([dotnet.typeof(InputArgs)])
- return get_method_wrapper(self.name, restype, args)
-
- def _get_args_array(self, arglist):
- array = dotnet.new_array(System.Type, len(arglist)+1)
- array[0] = System.Type.GetType("System.Object[]")
- for i in range(len(arglist)):
- array[i+1] = arglist[i]
- return array
-
- def var_for_box(self, box):
- try:
- return self.boxes[box]
- except KeyError:
- v = self.il.DeclareLocal(box.getCliType(self))
- self.boxes[box] = v
- return v
-
- def match_var_fox_boxes(self, failargs, inputargs):
- failargs = [arg for arg in failargs if arg is not None]
- assert len(failargs) == len(inputargs)
- for i in range(len(failargs)):
- v = self.boxes[failargs[i]]
- self.boxes[inputargs[i]] = v
-
- def get_index_for_failing_op(self, op):
- try:
- return self.cpu.failing_ops.index(op)
- except ValueError:
- self.cpu.failing_ops.append(op)
- return len(self.cpu.failing_ops)-1
-
- def get_index_for_constant(self, obj):
- try:
- return self.consts[obj]
- except KeyError:
- index = len(self.consts)
- self.consts[obj] = index
- return index
-
- def newbranch(self, op):
- # sanity check, maybe we can remove it later
- for myop in self.branches:
- assert myop is not op
- il_label = self.il.DefineLabel()
- self.branches.append(op)
- self.branchlabels.append(il_label)
- return il_label
-
- def get_inputarg_field(self, type):
- t = dotnet.typeof(InputArgs)
- if type == history.INT:
- fieldname = 'ints'
- elif type == history.FLOAT:
- fieldname = 'floats'
- elif type == history.REF:
- fieldname = 'objs'
- else:
- assert False, 'Unknown type %s' % type
- return t.GetField(fieldname)
-
- def load_inputarg(self, i, type, clitype):
- field = self.get_inputarg_field(type)
- self.av_inputargs.load(self)
- self.il.Emit(OpCodes.Ldfld, field)
- self.il.Emit(OpCodes.Ldc_I4, i)
- self.il.Emit(OpCodes.Ldelem, clitype)
-
- def store_inputarg(self, i, type, clitype, valuebox):
- field = self.get_inputarg_field(type)
- self.av_inputargs.load(self)
- self.il.Emit(OpCodes.Ldfld, field)
- self.il.Emit(OpCodes.Ldc_I4, i)
- valuebox.load(self)
- self.il.Emit(OpCodes.Stelem, clitype)
-
- def emit_load_inputargs(self):
- self.emit_debug("executing: " + self.name)
- i = 0
- for box in self.cliloop.inputargs:
- self.load_inputarg(i, box.type, box.getCliType(self))
- box.store(self)
- i+=1
-
- def emit_preamble(self):
- self.il_loop_start = self.il.DefineLabel()
- self.il.MarkLabel(self.il_loop_start)
-
- def emit_operations(self, oplist):
- self.i = 0
- self.oplist = oplist
- N = len(oplist)
- while self.i < N:
- op = oplist[self.i]
- self.emit_debug(op.repr())
- func = self.operations[op.getopnum()]
- assert func is not None
- func(self, op)
- self.i += 1
-
- def emit_branches(self):
- while self.branches:
- branches = self.branches
- branchlabels = self.branchlabels
- self.branches = []
- self.branchlabels = []
- assert len(branches) == len(branchlabels)
- for i in range(len(branches)):
- op = branches[i]
- il_label = branchlabels[i]
- self.il.MarkLabel(il_label)
- self.emit_guard_subops(op)
-
- def emit_guard_subops(self, op):
- assert op.is_guard()
- if op in self.cliloop.guard2ops:
- inputargs, suboperations = self.cliloop.guard2ops[op]
- self.match_var_fox_boxes(op.getfailargs(), inputargs)
- self.emit_operations(suboperations)
- else:
- self.emit_return_failed_op(op, op.getfailargs())
-
- def emit_end(self):
- assert self.branches == []
- self.il.Emit(OpCodes.Ret)
-
- # -----------------------------
-
- def push_all_args(self, op):
- for box in op.args:
- box.load(self)
-
- def push_arg(self, op, n):
- op.args[n].load(self)
-
- def store_result(self, op):
- op.result.store(self)
-
- def emit_debug(self, msg):
- if self.debug:
- self.il.EmitWriteLine(msg)
-
- def emit_clear_exception(self):
- self.av_inputargs.load(self)
- self.il.Emit(OpCodes.Ldnull)
- self.il.Emit(OpCodes.Stfld, self.exc_value_field)
- # clear the overflow flag
- self.il.Emit(OpCodes.Ldc_I4_0)
- self.av_ovf_flag.store(self)
-
- def emit_raising_op(self, op, emit_op, exctypes):
- self.emit_clear_exception()
- lbl = self.il.BeginExceptionBlock()
- emit_op(self, op)
- self.il.Emit(OpCodes.Leave, lbl)
- for exctype in exctypes:
- v = self.il.DeclareLocal(exctype)
- self.il.BeginCatchBlock(exctype)
- if exctype == dotnet.typeof(System.OverflowException) and self.av_OverflowError:
- self.il.Emit(OpCodes.Ldc_I4_1)
- self.av_ovf_flag.store(self)
- else:
- self.il.Emit(OpCodes.Stloc, v)
- self.av_inputargs.load(self)
- self.il.Emit(OpCodes.Ldloc, v)
- self.il.Emit(OpCodes.Stfld, self.exc_value_field)
- self.il.EndExceptionBlock()
-
- def emit_ovf_op(self, op, emit_op):
- next_op = self.oplist[self.i+1]
- if next_op.getopnum() == rop.GUARD_NO_OVERFLOW:
- self.i += 1
- self.emit_ovf_op_and_guard(op, next_op, emit_op)
- return
- # clear the overflow flag
- self.il.Emit(OpCodes.Ldc_I4_0)
- self.av_ovf_flag.store(self)
- lbl = self.il.BeginExceptionBlock()
- emit_op(self, op)
- self.il.Emit(OpCodes.Leave, lbl)
- self.il.BeginCatchBlock(dotnet.typeof(System.OverflowException))
- self.il.Emit(OpCodes.Ldc_I4_1)
- self.av_ovf_flag.store(self)
- self.il.EndExceptionBlock()
-
- def emit_ovf_op_and_guard(self, op, opguard, emit_op):
- # emit the checked operation
- lbl = self.il.BeginExceptionBlock()
- emit_op(self, op)
- self.il.Emit(OpCodes.Leave, lbl)
- self.il.BeginCatchBlock(dotnet.typeof(System.OverflowException))
- # emit the guard
- assert len(opguard.args) == 0
- il_label = self.newbranch(opguard)
- self.il.Emit(OpCodes.Leave, il_label)
- self.il.EndExceptionBlock()
-
- def mark(self, msg):
- self.il.Emit(OpCodes.Ldstr, msg)
- self.il.Emit(OpCodes.Pop)
-
- # --------------------------------
-
- def emit_return_failed_op(self, op, args):
- # store the index of the failed op
- index_op = self.get_index_for_failing_op(op)
- self.av_inputargs.load(self)
- self.il.Emit(OpCodes.Ldc_I4, index_op)
- field = dotnet.typeof(InputArgs).GetField('failed_op')
- self.il.Emit(OpCodes.Stfld, field)
- self.emit_store_opargs(args)
- self.il.Emit(OpCodes.Ret)
-
- def emit_op_finish(self, op):
- self.emit_return_failed_op(op, op.args)
-
- def emit_store_opargs(self, args):
- # store the latest values
- i = 0
- for box in args:
- if box is not None:
- self.store_inputarg(i, box.type, box.getCliType(self), box)
- i+=1
-
- def emit_guard_bool(self, op, opcode):
- assert len(op.args) == 1
- il_label = self.newbranch(op)
- op.args[0].load(self)
- self.il.Emit(opcode, il_label)
-
- def emit_op_guard_true(self, op):
- self.emit_guard_bool(op, OpCodes.Brfalse)
-
- def emit_op_guard_false(self, op):
- self.emit_guard_bool(op, OpCodes.Brtrue)
-
- def emit_op_guard_nonnull(self, op):
- self.emit_guard_bool(op, OpCodes.Brfalse)
-
- def emit_op_guard_isnull(self, op):
- self.emit_guard_bool(op, OpCodes.Brtrue)
-
- def emit_op_guard_value(self, op):
- assert len(op.args) == 2
- il_label = self.newbranch(op)
- self.push_all_args(op)
- self.il.Emit(OpCodes.Bne_Un, il_label)
-
- def emit_op_guard_class(self, op):
- assert len(op.args) == 2
- il_label = self.newbranch(op)
- self.push_arg(op, 0)
- meth = dotnet.typeof(System.Object).GetMethod("GetType")
- self.il.Emit(OpCodes.Callvirt, meth)
- self.push_arg(op, 1)
- self.il.Emit(OpCodes.Bne_Un, il_label)
-
- def emit_op_guard_nonnull_class(self, op):
- assert len(op.args) == 2
- il_label = self.newbranch(op)
- # nonnull check
- self.push_arg(op, 0)
- self.il.Emit(OpCodes.Brfalse, il_label)
- # class check
- self.push_arg(op, 0)
- meth = dotnet.typeof(System.Object).GetMethod("GetType")
- self.il.Emit(OpCodes.Callvirt, meth)
- self.push_arg(op, 1)
- self.il.Emit(OpCodes.Bne_Un, il_label)
-
- def emit_op_guard_no_exception(self, op):
- il_label = self.newbranch(op)
- self.av_inputargs.load(self)
- self.il.Emit(OpCodes.Ldfld, self.exc_value_field)
- self.il.Emit(OpCodes.Brtrue, il_label)
-
- def emit_op_guard_exception(self, op):
- il_label = self.newbranch(op)
- classbox = op.args[0]
- assert isinstance(classbox, ConstObj)
- oocls = classbox.getref(ootype.Class)
- clitype = dotnet.class2type(oocls)
- self.av_inputargs.load(self)
- self.il.Emit(OpCodes.Ldfld, self.exc_value_field)
- self.il.Emit(OpCodes.Isinst, clitype)
- self.il.Emit(OpCodes.Brfalse, il_label)
- # the guard succeeded, store the result
- self.av_inputargs.load(self)
- self.il.Emit(OpCodes.Ldfld, self.exc_value_field)
- self.store_result(op)
-
- def emit_guard_overflow_impl(self, op, opcode):
- assert len(op.args) == 0
- il_label = self.newbranch(op)
- self.av_ovf_flag.load(self)
- self.il.Emit(opcode, il_label)
-
- def emit_op_guard_no_overflow(self, op):
- self.emit_guard_overflow_impl(op, OpCodes.Brtrue)
-
- def emit_op_guard_overflow(self, op):
- self.emit_guard_overflow_impl(op, OpCodes.Brfalse)
-
- def emit_op_jump(self, op):
- target_token = op.getdescr()
- assert isinstance(target_token, LoopToken)
- if target_token.cliloop is self.cliloop:
- # jump to the beginning of the loop
- i = 0
- for i in range(len(op.args)):
- op.args[i].load(self)
- self.cliloop.inputargs[i].store(self)
- self.il.Emit(OpCodes.Br, self.il_loop_start)
- else:
- # it's a real bridge
- cliloop = target_token.cliloop
- assert len(op.args) == len(cliloop.inputargs)
- self.emit_debug('jumping to ' + cliloop.name)
- self.emit_store_opargs(op.args)
- cliloop.funcbox.load(self)
- self.av_inputargs.load(self)
- methinfo = dotnet.typeof(LoopDelegate).GetMethod('Invoke')
- if self.tailcall:
- self.il.Emit(OpCodes.Tailcall)
- self.il.Emit(OpCodes.Callvirt, methinfo)
- self.il.Emit(OpCodes.Ret)
-
- def emit_op_new_with_vtable(self, op):
- clsbox = op.args[0]
- assert isinstance(clsbox, ConstObj)
- cls = clsbox.getref_base()
- descr = self.cpu.class_sizes[cls]
- assert isinstance(descr, runner.TypeDescr)
- clitype = descr.get_clitype()
- ctor_info = descr.get_constructor_info()
- self.il.Emit(OpCodes.Newobj, ctor_info)
- self.store_result(op)
-
- def emit_op_runtimenew(self, op):
- clitype_utils = dotnet.typeof(Utils)
- methinfo = clitype_utils.GetMethod('RuntimeNew')
- op.args[0].load(self)
- self.il.Emit(OpCodes.Call, methinfo)
- self.store_result(op)
-
- def emit_op_instanceof(self, op):
- descr = op.getdescr()
- assert isinstance(descr, runner.TypeDescr)
- clitype = descr.get_clitype()
- op.args[0].load(self)
- self.il.Emit(OpCodes.Isinst, clitype)
- self.il.Emit(OpCodes.Ldnull)
- self.il.Emit(OpCodes.Cgt_Un)
- self.store_result(op)
-
- def emit_op_subclassof(self, op):
- clitype_utils = dotnet.typeof(Utils)
- methinfo = clitype_utils.GetMethod('SubclassOf')
- op.args[0].load(self)
- op.args[1].load(self)
- self.il.Emit(OpCodes.Call, methinfo)
- self.store_result(op)
-
- def emit_op_call_impl(self, op):
- descr = op.getdescr()
- assert isinstance(descr, runner.StaticMethDescr)
- delegate_type = descr.get_delegate_clitype()
- meth_invoke = descr.get_meth_info()
- self._emit_call(op, OpCodes.Callvirt, delegate_type,
- meth_invoke, descr.has_result)
-
- def emit_op_call(self, op):
- emit_op = Method.emit_op_call_impl.im_func
- exctypes = [dotnet.typeof(System.Exception)]
- self.emit_raising_op(op, emit_op, exctypes)
-
- emit_op_call_pure = emit_op_call
-
- def emit_op_oosend(self, op):
- descr = op.getdescr()
- assert isinstance(descr, runner.MethDescr)
- clitype = descr.get_self_clitype()
- methinfo = descr.get_meth_info()
- opcode = descr.get_call_opcode()
- self._emit_call(op, opcode, clitype, methinfo, descr.has_result)
-
- emit_op_oosend_pure = emit_op_oosend
-
- def _emit_call(self, op, opcode, clitype, methinfo, has_result):
- av_sm, args_av = op.args[0], op.args[1:]
- av_sm.load(self)
- self.il.Emit(OpCodes.Castclass, clitype)
- for av_arg in args_av:
- av_arg.load(self)
- self.il.Emit(opcode, methinfo)
- if has_result:
- self.store_result(op)
-
- def emit_op_getfield_gc(self, op):
- descr = op.getdescr()
- assert isinstance(descr, runner.FieldDescr)
- clitype = descr.get_self_clitype()
- fieldinfo = descr.get_field_info()
- obj = op.args[0]
- obj.load(self)
- if obj.getCliType(self) is not clitype:
- self.il.Emit(OpCodes.Castclass, clitype)
- self.il.Emit(OpCodes.Ldfld, fieldinfo)
- self.store_result(op)
-
- emit_op_getfield_gc_pure = emit_op_getfield_gc
-
- def emit_op_setfield_gc(self, op):
- descr = op.getdescr()
- assert isinstance(descr, runner.FieldDescr)
- clitype = descr.get_self_clitype()
- fieldinfo = descr.get_field_info()
- obj = op.args[0]
- obj.load(self)
- if obj.getCliType(self) is not clitype:
- self.il.Emit(OpCodes.Castclass, clitype)
- op.args[1].load(self)
- self.il.Emit(OpCodes.Stfld, fieldinfo)
-
- def emit_op_getarrayitem_gc(self, op):
- descr = op.getdescr()
- assert isinstance(descr, runner.TypeDescr)
- clitype = descr.get_array_clitype()
- itemtype = descr.get_clitype()
- op.args[0].load(self)
- self.il.Emit(OpCodes.Castclass, clitype)
- op.args[1].load(self)
- self.il.Emit(OpCodes.Ldelem, itemtype)
- self.store_result(op)
-
- emit_op_getarrayitem_gc_pure = emit_op_getarrayitem_gc
-
- def emit_op_setarrayitem_gc(self, op):
- descr = op.getdescr()
- assert isinstance(descr, runner.TypeDescr)
- clitype = descr.get_array_clitype()
- itemtype = descr.get_clitype()
- op.args[0].load(self)
- self.il.Emit(OpCodes.Castclass, clitype)
- op.args[1].load(self)
- op.args[2].load(self)
- self.il.Emit(OpCodes.Stelem, itemtype)
-
- def emit_op_arraylen_gc(self, op):
- descr = op.getdescr()
- assert isinstance(descr, runner.TypeDescr)
- clitype = descr.get_array_clitype()
- op.args[0].load(self)
- self.il.Emit(OpCodes.Castclass, clitype)
- self.il.Emit(OpCodes.Ldlen)
- self.store_result(op)
-
- def emit_op_new_array(self, op):
- descr = op.getdescr()
- assert isinstance(descr, runner.TypeDescr)
- item_clitype = descr.get_clitype()
- if item_clitype is None:
- return self.emit_new_arrayofvoids(op)
- op.args[0].load(self)
- self.il.Emit(OpCodes.Newarr, item_clitype)
- self.store_result(op)
-
- def emit_new_arrayofvoids(self, op):
- clitype = dotnet.typeof(ListOfVoid)
- ctor = clitype.GetConstructor(dotnet.new_array(System.Type, 0))
- _ll_resize = clitype.GetMethod('_ll_resize')
- self.il.Emit(OpCodes.Newobj, ctor)
- self.il.Emit(OpCodes.Dup)
- op.args[0].load(self)
- self.il.Emit(OpCodes.Callvirt, _ll_resize)
- self.store_result(op)
-
- def emit_op_debug_merge_point(self, op):
- pass
-
- def lltype_only(self, op):
- print 'Operation %s is lltype specific, should not get here!' % op.getopname()
- raise NotImplementedError
-
- emit_op_new = lltype_only
- emit_op_setfield_raw = lltype_only
- emit_op_getfield_raw = lltype_only
- emit_op_getfield_raw_pure = lltype_only
- emit_op_strsetitem = lltype_only
- emit_op_unicodesetitem = lltype_only
- emit_op_cast_int_to_ptr = lltype_only
- emit_op_cast_ptr_to_int = lltype_only
- emit_op_newstr = lltype_only
- emit_op_strlen = lltype_only
- emit_op_strgetitem = lltype_only
- emit_op_newunicode = lltype_only
- emit_op_unicodelen = lltype_only
- emit_op_unicodegetitem = lltype_only
- emit_op_cond_call_gc_wb = lltype_only
- emit_op_setarrayitem_raw = lltype_only
-
-
-# --------------------------------------------------------------------
-
-# the follwing functions automatically build the various emit_op_*
-# operations based on the definitions in translator/cli/opcodes.py
-
-def make_operation_list():
- operations = [None] * (rop._LAST+1)
- for key, value in rop.__dict__.items():
- key = key.lower()
- if key.startswith('_'):
- continue
- methname = 'emit_op_%s' % key
- if hasattr(Method, methname):
- func = getattr(Method, methname).im_func
- else:
- instrlist = opcodes.opcodes[key]
- func = render_op(methname, instrlist)
- operations[value] = func
- return operations
-
-def is_raising_op(instrlist):
- return len(instrlist) == 1 and isinstance(instrlist[0], opcodes.MapException)
-
-def render_op(methname, instrlist):
- if is_raising_op(instrlist):
- return render_raising_op(methname, instrlist)
- lines = []
- for instr in instrlist:
- if instr == opcodes.PushAllArgs:
- lines.append('self.push_all_args(op)')
- elif instr == opcodes.StoreResult:
- lines.append('self.store_result(op)')
- elif isinstance(instr, opcodes.PushArg):
- lines.append('self.push_arg(op, %d)' % instr.n)
- elif instr == 'ldc.r8 0':
- lines.append('Utils.Emit_Ldc_R8(self.il, 0.0)')
- else:
- assert isinstance(instr, str), 'unknown instruction %s' % instr
- if instr.startswith('call '):
- signature = instr[len('call '):]
- renderCall(lines, signature)
- else:
- attrname = opcode2attrname(instr)
- lines.append('self.il.Emit(OpCodes.%s)' % attrname)
- body = py.code.Source('\n'.join(lines))
- src = body.putaround('def %s(self, op):' % methname)
- dic = {'OpCodes': OpCodes,
- 'System': System,
- 'Utils': Utils,
- 'dotnet': dotnet}
- exec src.compile() in dic
- return dic[methname]
-
-def parse_exctype(exctype):
- assert exctype.startswith('[mscorlib]')
- return exctype[len('[mscorlib]'):]
-
-
-def render_raising_op(methname, instrlist):
- value = instrlist[0]
- exctypes = [parse_exctype(exctype) for exctype, _ in value.mapping]
- exctypes = ['dotnet.typeof(%s)' % exctype for exctype in exctypes]
- is_ovf = (exctypes == ['dotnet.typeof(System.OverflowException)'])
- impl_func = render_op(methname + '_impl', value.instr)
- if not impl_func:
- return
- if is_ovf:
- src = py.code.Source("""
- def %s(self, op):
- self.emit_ovf_op(op, impl_func)
- """ % (methname,))
- else:
- src = py.code.Source("""
- def %s(self, op):
- exctypes = [%s]
- self.emit_raising_op(op, impl_func, exctypes)
- """ % (methname, ', '.join(exctypes)))
- dic = {'System': System,
- 'dotnet': dotnet,
- 'impl_func': impl_func}
- exec src.compile() in dic
- return dic[methname]
-
-def opcode2attrname(opcode):
- if opcode == 'ldc.r8 0':
- return 'Ldc_R8, 0' # XXX this is a hack
- if opcode == 'ldc.i8 0':
- return 'Ldc_I8, 0' # XXX this is a hack
- parts = map(str.capitalize, opcode.split('.'))
- return '_'.join(parts)
-
-def renderCall(body, signature):
- # signature is like this:
- # int64 class [mscorlib]System.Foo::Bar(int64, int32)
-
- typenames = {
- 'int32': 'System.Int32',
- 'int64': 'System.Int64',
- 'float64': 'System.Double',
- }
-
- restype, _, signature = signature.split(' ', 3)
- assert signature.startswith('[mscorlib]'), 'external assemblies '\
- 'not supported'
- signature = signature[len('[mscorlib]'):]
- typename, signature = signature.split('::')
- methname, signature = signature.split('(')
- assert signature.endswith(')')
- params = signature[:-1].split(',')
- params = map(str.strip, params)
- params = [typenames.get(p, p) for p in params]
- params = ['dotnet.typeof(%s)' % p for p in params]
-
- body.append("t = System.Type.GetType('%s')" % typename)
- body.append("params = dotnet.init_array(System.Type, %s)" % ', '.join(params))
- body.append("methinfo = t.GetMethod('%s', params)" % methname)
- body.append("self.il.Emit(OpCodes.Call, methinfo)")
-
-Method.operations = make_operation_list()
diff --git a/rpython/jit/backend/cli/methodfactory.py b/rpython/jit/backend/cli/methodfactory.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/methodfactory.py
+++ /dev/null
@@ -1,86 +0,0 @@
-import os
-from rpython.translator.cli.dotnet import CLR
-from rpython.translator.cli import dotnet
-System = CLR.System
-Utils = CLR.pypy.runtime.Utils
-AutoSaveAssembly = CLR.pypy.runtime.AutoSaveAssembly
-MethodAttributes = System.Reflection.MethodAttributes
-TypeAttributes = System.Reflection.TypeAttributes
-
-class AbstractMethodWrapper:
-
- def get_il_generator(self):
- raise NotImplementedError
-
- def create_delegate(self, delegatetype, consts):
- raise NotImplementedError
-
-class DynamicMethodWrapper(AbstractMethodWrapper):
-
- def __init__(self, name, res, args):
- self.dynmeth = Utils.CreateDynamicMethod(name, res, args)
-
- def get_il_generator(self):
- return self.dynmeth.GetILGenerator()
-
- def create_delegate(self, delegatetype, consts):
- return self.dynmeth.CreateDelegate(delegatetype, consts)
-
-
-# the assemblyData singleton contains the information about the
-# assembly we are currently writing to
-class AssemblyData:
- assembly = None
- name = None
- methcount = 0
-
- def is_enabled(self):
- if self.name is None:
- name = os.environ.get('PYPYJITLOG')
- if name is None:
- name = ''
- self.name = name
- return bool(self.name)
-
- def create(self):
- assert self.is_enabled()
- if self.assembly is None:
- name = self.name
- self.auto_save_assembly = AutoSaveAssembly.Create(name)
- self.assembly = self.auto_save_assembly.GetAssemblyBuilder()
- self.module = self.assembly.DefineDynamicModule(name)
-
-assemblyData = AssemblyData()
-
-
-class AssemblyMethodWrapper(AbstractMethodWrapper):
-
- def __init__(self, name, res, args):
- module = assemblyData.module
- name = '%s_%d' % (name, assemblyData.methcount)
- #self.name = name
- assemblyData.methcount += 1
- self.typeBuilder = AutoSaveAssembly.DefineType(module, name)
- self.meth = AutoSaveAssembly.DefineMethod(self.typeBuilder,
- "invoke", res, args)
-
-
- def get_il_generator(self):
- return self.meth.GetILGenerator()
-
- def create_delegate(self, delegatetype, consts):
- t = self.typeBuilder.CreateType()
- methinfo = t.GetMethod("invoke")
-## if self.name == 'Loop1(r0)_1':
-## assemblyData.auto_save_assembly.Save()
- return System.Delegate.CreateDelegate(delegatetype,
- consts,
- methinfo)
-
-def get_method_wrapper(name, res, args):
- if assemblyData.is_enabled():
- assemblyData.create()
- return AssemblyMethodWrapper(name, res, args)
- else:
- return DynamicMethodWrapper(name, res, args)
-
diff --git a/rpython/jit/backend/cli/runner.py b/rpython/jit/backend/cli/runner.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/runner.py
+++ /dev/null
@@ -1,532 +0,0 @@
-from rpython.tool.pairtype import extendabletype
-from rpython.rtyper.ootypesystem import ootype
-from rpython.rlib.objectmodel import we_are_translated
-from rpython.jit.metainterp import history
-from rpython.jit.metainterp.history import AbstractDescr, AbstractMethDescr
-from rpython.jit.metainterp.history import AbstractFailDescr, LoopToken
-from rpython.jit.metainterp.history import Box, BoxInt, BoxObj, ConstObj, Const
-from rpython.jit.metainterp import executor
-from rpython.jit.metainterp.resoperation import rop, opname
-from rpython.jit.backend import model
-from rpython.jit.backend.llgraph.runner import KeyManager
-from rpython.translator.cli import dotnet
-from rpython.translator.cli.dotnet import CLR
-from rpython.jit.metainterp.typesystem import oohelper
-
-System = CLR.System
-OpCodes = System.Reflection.Emit.OpCodes
-InputArgs = CLR.pypy.runtime.InputArgs
-cpypyString = dotnet.classof(CLR.pypy.runtime.String)
-
-LoopToken.cliloop = None
-AbstractFailDescr._loop_token = None
-AbstractFailDescr._guard_op = None
-
-class CliLoop(object):
-
- def __init__(self, name, inputargs, operations):
- self.name = name
- self.inputargs = inputargs
- self.operations = operations
- self.guard2ops = {} # guard_op --> (inputargs, operations)
- self.funcbox = None
- self.methcount = 0
-
- def get_fresh_cli_name(self):
- name = '%s(r%d)' % (self.name, self.methcount)
- self.methcount += 1
- return name
-
-
-class CliCPU(model.AbstractCPU):
-
- supports_floats = True
- ts = oohelper
-
- def __init__(self, rtyper, stats, opts=None, translate_support_code=False,
- mixlevelann=None, gcdescr=None):
- model.AbstractCPU.__init__(self)
- self.rtyper = rtyper
- if rtyper:
- assert rtyper.type_system.name == "ootypesystem"
- self.loopcount = 0
- self.stats = stats
- self.translate_support_code = translate_support_code
- self.inputargs = None
- self.failing_ops = [] # index --> op
- self.ll_ovf_exc = self._get_prebuilt_exc(OverflowError)
- self.ll_zero_exc = self._get_prebuilt_exc(ZeroDivisionError)
-
- def _get_prebuilt_exc(self, cls):
- if self.rtyper is None:
- return System.Exception()
- else:
- bk = self.rtyper.annotator.bookkeeper
- clsdef = bk.getuniqueclassdef(cls)
- return self.rtyper.exceptiondata.get_standard_ll_exc_instance(
- self.rtyper, clsdef)
-
- def get_inputargs(self):
- if self.inputargs is None:
- self.inputargs = InputArgs()
- return self.inputargs
-
- @staticmethod
- def calldescrof(FUNC, ARGS, RESULT, extrainfo=None):
- return StaticMethDescr.new(FUNC, ARGS, RESULT, extrainfo)
-
- @staticmethod
- def methdescrof(SELFTYPE, methname):
- if SELFTYPE in (ootype.String, ootype.Unicode):
- return StringMethDescr.new(SELFTYPE, methname)
- return MethDescr.new(SELFTYPE, methname)
-
- @staticmethod
- def typedescrof(TYPE):
- return TypeDescr.new(TYPE)
-
- @staticmethod
- def arraydescrof(A):
- assert isinstance(A, ootype.Array)
- TYPE = A.ITEM
- return TypeDescr.new(TYPE)
-
- @staticmethod
- def fielddescrof(T, fieldname):
- T1, _ = T._lookup_field(fieldname)
- return FieldDescr.new(T1, fieldname)
-
- def typedescr2classbox(self, descr):
- assert isinstance(descr, TypeDescr)
- return ConstObj(ootype.cast_to_object(descr.ooclass))
-
- # ----------------------
-
- def _attach_token_to_faildescrs(self, token, operations):
- for op in operations:
- if op.is_guard():
- descr = op.getdescr()
- assert isinstance(descr, AbstractFailDescr)
- descr._loop_token = token
- descr._guard_op = op
-
- def compile_loop(self, inputargs, operations, looptoken):
- from rpython.jit.backend.cli.method import Method, ConstFunction
- name = 'Loop%d' % self.loopcount
- self.loopcount += 1
- cliloop = CliLoop(name, inputargs, operations)
- looptoken.cliloop = cliloop
- cliloop.funcbox = ConstFunction(cliloop.name)
- self._attach_token_to_faildescrs(cliloop, operations)
- meth = Method(self, cliloop)
- cliloop.funcbox.holder.SetFunc(meth.compile())
-
- def compile_bridge(self, faildescr, inputargs, operations):
- from rpython.jit.backend.cli.method import Method
- op = faildescr._guard_op
- token = faildescr._loop_token
- token.guard2ops[op] = (inputargs, operations)
- self._attach_token_to_faildescrs(token, operations)
- meth = Method(self, token)
- token.funcbox.holder.SetFunc(meth.compile())
- return token
-
- def execute_token(self, looptoken):
- cliloop = looptoken.cliloop
- func = cliloop.funcbox.holder.GetFunc()
- func(self.get_inputargs())
- op = self.failing_ops[self.inputargs.get_failed_op()]
- return op.getdescr()
-
- def set_future_value_int(self, index, intvalue):
- self.get_inputargs().set_int(index, intvalue)
-
- def set_future_value_float(self, index, intvalue):
- self.get_inputargs().set_float(index, intvalue)
-
- def set_future_value_ref(self, index, objvalue):
- obj = dotnet.cast_to_native_object(objvalue)
- self.get_inputargs().set_obj(index, obj)
-
- def get_latest_value_int(self, index):
- return self.get_inputargs().get_int(index)
-
- def get_latest_value_float(self, index):
- return self.get_inputargs().get_float(index)
-
- def get_latest_value_ref(self, index):
- obj = self.get_inputargs().get_obj(index)
- return dotnet.cast_from_native_object(obj)
-
- def get_exception(self):
- exc_value = self.get_inputargs().get_exc_value()
- if exc_value:
- exc_obj = dotnet.cast_from_native_object(exc_value)
- exc_inst = ootype.cast_from_object(ootype.ROOT, exc_obj)
- cls = ootype.classof(exc_value)
- return ootype.cast_to_object(cls)
- return ootype.cast_to_object(ootype.nullruntimeclass)
-
- def get_exc_value(self):
- exc_value = self.get_inputargs().get_exc_value()
- if exc_value:
- return dotnet.cast_from_native_object(exc_value)
- else:
- return ootype.NULL
-
- def clear_exception(self):
- self.get_inputargs().set_exc_value(None)
-
- def get_overflow_error(self):
- exc_type = ootype.cast_to_object(ootype.classof(self.ll_ovf_exc))
- exc_value = ootype.cast_to_object(self.ll_ovf_exc)
- return exc_type, exc_value
-
- def get_zero_division_error(self):
- exc_type = ootype.cast_to_object(ootype.classof(self.ll_zero_exc))
- exc_value = ootype.cast_to_object(self.ll_zero_exc)
- return exc_type, exc_value
-
- def set_overflow_error(self):
- exc_obj = ootype.cast_to_object(self.ll_ovf_exc)
- exc_value = dotnet.cast_to_native_object(exc_obj)
- self.get_inputargs().set_exc_value(exc_value)
-
- def set_zero_division_error(self):
- exc_obj = ootype.cast_to_object(self.ll_zero_exc)
- exc_value = dotnet.cast_to_native_object(exc_obj)
- self.get_inputargs().set_exc_value(exc_value)
-
- # ----------------------
-
- def do_new_with_vtable(self, classbox):
- cls = classbox.getref_base()
- typedescr = self.class_sizes[cls]
- return typedescr.create()
-
- def do_new_array(self, lengthbox, typedescr):
- assert isinstance(typedescr, TypeDescr)
- return typedescr.create_array(lengthbox)
-
- def do_runtimenew(self, classbox):
- classobj = classbox.getref(ootype.Class)
- res = ootype.runtimenew(classobj)
- return BoxObj(ootype.cast_to_object(res))
-
- def do_instanceof(self, instancebox, typedescr):
- assert isinstance(typedescr, TypeDescr)
- return typedescr.instanceof(instancebox)
-
- def do_getfield_gc(self, instancebox, fielddescr):
- assert isinstance(fielddescr, FieldDescr)
- assert fielddescr.getfield is not None
- return fielddescr.getfield(instancebox)
-
- def do_setfield_gc(self, instancebox, newvaluebox, fielddescr):
- assert isinstance(fielddescr, FieldDescr)
- assert fielddescr.setfield is not None
- return fielddescr.setfield(instancebox, newvaluebox)
-
- def do_call(self, args, calldescr):
- assert isinstance(calldescr, StaticMethDescr)
- funcbox, args = args[0], args[1:]
- self.clear_exception()
- try:
- return calldescr.callfunc(funcbox, args)
- except Exception, e:
- exc_value = self._cast_instance_to_native_obj(e)
- self.get_inputargs().set_exc_value(exc_value)
- return calldescr.get_errbox()
-
- def _cast_instance_to_native_obj(self, e):
- from rpython.rtyper.annlowlevel import cast_instance_to_base_obj
- inst = cast_instance_to_base_obj(e) # SomeOOInstance
- obj = ootype.cast_to_object(inst) # SomeOOObject
- return dotnet.cast_to_native_object(obj) # System.Object
-
- def do_oosend(self, args, descr):
- assert isinstance(descr, MethDescr)
- assert descr.callmeth is not None
- selfbox = args[0]
- argboxes = args[1:]
- return descr.callmeth(selfbox, argboxes)
-
- def do_getarrayitem_gc(self, arraybox, indexbox, descr):
- assert isinstance(descr, TypeDescr)
- return descr.getarrayitem(arraybox, indexbox)
-
- def do_setarrayitem_gc(self, arraybox, indexbox, newvaluebox, descr):
- assert isinstance(descr, TypeDescr)
- descr.setarrayitem(arraybox, indexbox, newvaluebox)
-
- def do_arraylen_gc(self, arraybox, descr):
- assert isinstance(descr, TypeDescr)
- return descr.getarraylength(arraybox)
-
-# ----------------------------------------------------------------------
-key_manager = KeyManager()
-
-descr_cache = {}
-class DescrWithKey(AbstractDescr):
- key = -1
-
- @classmethod
- def new(cls, *args):
- 'NOT_RPYTHON'
- key = (cls, args)
- try:
- return descr_cache[key]
- except KeyError:
- res = cls(*args)
- descr_cache[key] = res
- return res
-
-
- def __init__(self, key):
- self.key = key_manager.getkey(key)
-
- def sort_key(self):
- return self.key
-
- def short_repr(self):
- return ''
-
- def repr_of_descr(self):
- return self.short_repr()
-
-
-def get_class_for_type(T):
- if T is ootype.Void:
- return ootype.nullruntimeclass
- elif T is ootype.Signed:
- return dotnet.classof(System.Int32)
- elif T is ootype.Unsigned:
- return dotnet.classof(System.UInt32)
- elif T is ootype.Bool:
- return dotnet.classof(System.Boolean)
- elif T is ootype.Float:
- return dotnet.classof(System.Double)
-## elif T is ootype.String:
-## return dotnet.classof(System.String)
- elif T in (ootype.Char, ootype.UniChar):
- return dotnet.classof(System.Char)
- elif isinstance(T, ootype.OOType):
- return ootype.runtimeClass(T)
- else:
- assert False
-
-class TypeDescr(DescrWithKey):
-
- def __init__(self, TYPE):
- DescrWithKey.__init__(self, TYPE)
- from rpython.jit.backend.llgraph.runner import boxresult
- from rpython.jit.metainterp.warmstate import unwrap
- ARRAY = ootype.Array(TYPE)
- def create():
- if isinstance(TYPE, ootype.OOType):
- return boxresult(TYPE, ootype.new(TYPE))
- return None
- def create_array(lengthbox):
- n = lengthbox.getint()
- return boxresult(ARRAY, ootype.oonewarray(ARRAY, n))
- def getarrayitem(arraybox, ibox):
- array = arraybox.getref(ARRAY)
- i = ibox.getint()
- if TYPE is not ootype.Void:
- return boxresult(TYPE, array.ll_getitem_fast(i))
- def setarrayitem(arraybox, ibox, valuebox):
- array = arraybox.getref(ARRAY)
- i = ibox.getint()
- value = unwrap(TYPE, valuebox)
- array.ll_setitem_fast(i, value)
- def getarraylength(arraybox):
- array = arraybox.getref(ARRAY)
- return boxresult(ootype.Signed, array.ll_length())
- def instanceof(box):
- if isinstance(TYPE, ootype.Instance):
- obj = box.getref(ootype.ROOT)
- return BoxInt(ootype.instanceof(obj, TYPE))
- return None
- self.create = create
- self.create_array = create_array
- self.getarrayitem = getarrayitem
- self.setarrayitem = setarrayitem
- self.getarraylength = getarraylength
- self.instanceof = instanceof
- self.ooclass = get_class_for_type(TYPE)
- self.typename = TYPE._short_name()
- self._is_array_of_pointers = (history.getkind(TYPE) == 'ref')
- self._is_array_of_floats = (history.getkind(TYPE) == 'float')
-
- def is_array_of_pointers(self):
- # for arrays, TYPE is the type of the array item.
- return self._is_array_of_pointers
-
- def is_array_of_floats(self):
- # for arrays, TYPE is the type of the array item.
- return self._is_array_of_floats
-
- def get_clitype(self):
- return dotnet.class2type(self.ooclass)
-
- def get_array_clitype(self):
- return self.get_clitype().MakeArrayType()
-
- def get_constructor_info(self):
- clitype = self.get_clitype()
- return clitype.GetConstructor(dotnet.new_array(System.Type, 0))
-
- def short_repr(self):
- return self.typename
-
-class StaticMethDescr(DescrWithKey):
-
- callfunc = None
- funcclass = ootype.nullruntimeclass
- has_result = False
-
- def __init__(self, FUNC, ARGS, RESULT, extrainfo=None):
- DescrWithKey.__init__(self, (FUNC, ARGS, RESULT))
- from rpython.jit.backend.llgraph.runner import boxresult, make_getargs
- getargs = make_getargs(FUNC.ARGS)
- def callfunc(funcbox, argboxes):
- funcobj = funcbox.getref(FUNC)
- funcargs = getargs(argboxes)
- res = funcobj(*funcargs)
- if RESULT is not ootype.Void:
- return boxresult(RESULT, res)
- self.callfunc = callfunc
- self.funcclass = dotnet.classof(FUNC)
- self.has_result = (FUNC.RESULT != ootype.Void)
- self.extrainfo = extrainfo
- if RESULT is ootype.Void:
- def get_errbox():
- return None
- elif isinstance(RESULT, ootype.OOType):
- def get_errbox():
- return BoxObj()
- else:
- def get_errbox():
- return BoxInt()
- self.get_errbox = get_errbox
-
- def get_delegate_clitype(self):
- return dotnet.class2type(self.funcclass)
-
- def get_meth_info(self):
- clitype = self.get_delegate_clitype()
- return clitype.GetMethod('Invoke')
-
- def get_extra_info(self):
- return self.extrainfo
-
-
-class MethDescr(AbstractMethDescr):
-
- callmeth = None
- selfclass = ootype.nullruntimeclass
- methname = ''
- has_result = False
- key = -1
-
- new = classmethod(DescrWithKey.new.im_func)
-
- def __init__(self, SELFTYPE, methname):
- from rpython.jit.backend.llgraph.runner import boxresult, make_getargs
- _, meth = SELFTYPE._lookup(methname)
- METH = ootype.typeOf(meth)
- getargs = make_getargs(METH.ARGS)
- def callmeth(selfbox, argboxes):
- selfobj = selfbox.getref(SELFTYPE)
- meth = getattr(selfobj, methname)
- methargs = getargs(argboxes)
- res = meth(*methargs)
- if METH.RESULT is not ootype.Void:
- return boxresult(METH.RESULT, res)
- self.callmeth = callmeth
- self.selfclass = ootype.runtimeClass(SELFTYPE)
- self.methname = methname
- self.has_result = (METH.RESULT != ootype.Void)
- self.key = key_manager.getkey((SELFTYPE, methname))
-
- def sort_key(self):
- return self.key
-
- def get_self_clitype(self):
- return dotnet.class2type(self.selfclass)
-
- def get_meth_info(self):
- clitype = self.get_self_clitype()
- return clitype.GetMethod(self.methname+'')
-
- def get_call_opcode(self):
- return OpCodes.Callvirt
-
- def repr_of_descr(self):
- return "'%s'" % self.methname
-
-class StringMethDescr(MethDescr):
-
- def get_meth_info(self):
- clitype = dotnet.class2type(cpypyString)
- return clitype.GetMethod(self.methname+'')
-
- def get_call_opcode(self):
- return OpCodes.Call
-
-
-class FieldDescr(DescrWithKey):
-
- getfield = None
- setfield = None
- selfclass = ootype.nullruntimeclass
- fieldname = ''
- _is_pointer_field = False
- _is_float_field = False
-
- def __init__(self, TYPE, fieldname):
- DescrWithKey.__init__(self, (TYPE, fieldname))
- from rpython.jit.backend.llgraph.runner import boxresult
- from rpython.jit.metainterp.warmstate import unwrap
- _, T = TYPE._lookup_field(fieldname)
- def getfield(objbox):
- obj = objbox.getref(TYPE)
- value = getattr(obj, fieldname)
- return boxresult(T, value)
- def setfield(objbox, valuebox):
- obj = objbox.getref(TYPE)
- value = unwrap(T, valuebox)
- setattr(obj, fieldname, value)
-
- self.getfield = getfield
- self.setfield = setfield
- self.selfclass = ootype.runtimeClass(TYPE)
- self.fieldname = fieldname
- self.key = key_manager.getkey((TYPE, fieldname))
- self._is_pointer_field = (history.getkind(T) == 'ref')
- self._is_float_field = (history.getkind(T) == 'float')
-
- def is_pointer_field(self):
- return self._is_pointer_field
-
- def is_float_field(self):
- return self._is_float_field
-
- def equals(self, other):
- assert isinstance(other, FieldDescr)
- return self.key == other.key
-
- def get_self_clitype(self):
- return dotnet.class2type(self.selfclass)
-
- def get_field_info(self):
- clitype = self.get_self_clitype()
- return clitype.GetField(self.fieldname+'')
-
- def short_repr(self):
- return "'%s'" % self.fieldname
-
-CPU = CliCPU
-
-import rpython.jit.metainterp.executor
-rpython.jit.metainterp.executor.make_execute_list(CPU)
diff --git a/rpython/jit/backend/cli/test/__init__.py b/rpython/jit/backend/cli/test/__init__.py
deleted file mode 100644
diff --git a/rpython/jit/backend/cli/test/conftest.py b/rpython/jit/backend/cli/test/conftest.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/test/conftest.py
+++ /dev/null
@@ -1,4 +0,0 @@
-import py
-
-def pytest_ignore_collect(path):
- return True
diff --git a/rpython/jit/backend/cli/test/test_basic.py b/rpython/jit/backend/cli/test/test_basic.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/test/test_basic.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import py
-from rpython.jit.backend.cli.runner import CliCPU
-from rpython.jit.metainterp.test import support, test_ajit
-
-class CliJitMixin(suport.OOJitMixin):
- CPUClass = CliCPU
- def setup_class(cls):
- from rpython.translator.cli.support import PythonNet
- PythonNet.System # possibly raises Skip
-
-class TestBasic(CliJitMixin, test_ajit.TestOOtype):
- # for the individual tests see
- # ====> ../../../metainterp/test/test_basic.py
-
- def skip(self):
- py.test.skip("works only after translation")
-
- test_string = skip
- test_chr2str = skip
- test_unicode = skip
- test_residual_call = skip
- test_constant_across_mp = skip
- test_format = skip
- test_getfield = skip
- test_getfield_immutable = skip
- test_print = skip
- test_bridge_from_interpreter_2 = skip
- test_bridge_from_interpreter_3 = skip
- test_bridge_leaving_interpreter_5 = skip
- test_instantiate_classes = skip
- test_zerodivisionerror = skip
- test_isinstance = skip
- test_isinstance_2 = skip
- test_oois = skip
- test_oostring_instance = skip
- test_long_long = skip
- test_free_object = skip
- test_stopatxpolicy = skip
- test_residual_call_pure = skip
- test_div_overflow = skip
- test_subclassof = skip
- test_assert_isinstance = skip
- test_dont_look_inside = skip
- test_setfield_bool = skip
- test_instantiate_does_not_call = skip
- test_listcomp = skip
- test_tuple_immutable = skip
- test_oosend_look_inside_only_one = skip
- test_residual_external_call = skip
- test_merge_guardclass_guardvalue = skip
- test_merge_guardnonnull_guardclass = skip
- test_merge_guardnonnull_guardvalue = skip
- test_merge_guardnonnull_guardvalue_2 = skip
- test_merge_guardnonnull_guardclass_guardvalue = skip
- test_residual_call_doesnt_lose_info = skip
- test_oohash = skip
- test_identityhash = skip
- test_guard_isnull_nonnull = skip
- test_r_dict = skip
diff --git a/rpython/jit/backend/cli/test/test_descr.py b/rpython/jit/backend/cli/test/test_descr.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/test/test_descr.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from rpython.rtyper.ootypesystem import ootype
-from rpython.jit.backend.cli.runner import CliCPU
-
-
-def test_fielddescr_ootype():
- A = ootype.Instance("A", ootype.ROOT, {"foo": ootype.Signed})
- B = ootype.Instance("B", A)
- descr1 = CliCPU.fielddescrof(A, "foo")
- descr2 = CliCPU.fielddescrof(B, "foo")
- assert descr1 is descr2
-
-def test_call_descr_extra_info():
- FUNC = ootype.StaticMethod([], ootype.Signed)
- ARGS = ()
- descr1 = CliCPU.calldescrof(FUNC, ARGS, ootype.Signed, "hello")
- extrainfo = descr1.get_extra_info()
- assert extrainfo == "hello"
-
- descr2 = CliCPU.calldescrof(FUNC, ARGS, ootype.Signed, "hello")
- assert descr2 is descr1
-
- descr3 = CliCPU.calldescrof(FUNC, ARGS, ootype.Signed)
- assert descr3 is not descr1
- assert descr3.get_extra_info() is None
diff --git a/rpython/jit/backend/cli/test/test_exception.py b/rpython/jit/backend/cli/test/test_exception.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/test/test_exception.py
+++ /dev/null
@@ -1,28 +0,0 @@
-import py
-from rpython.jit.metainterp.test import test_exception
-from rpython.jit.backend.cli.test.test_basic import CliJitMixin
-
-
-class TestException(CliJitMixin, test_exception.TestOOtype):
- # for the individual tests see
- # ====> ../../../metainterp/test/test_exception.py
-
- def skip(self):
- py.test.skip("works only after translation")
-
- test_simple = skip
- test_bridge_from_guard_exception = skip
- test_bridge_from_guard_no_exception = skip
- test_four_levels_checks = skip
- test_exception_from_outside = skip
- test_exception_from_outside_2 = skip
- test_exception_two_cases = skip
- test_exception_two_cases_2 = skip
- test_exception_four_cases = skip
- test_exception_later = skip
- test_exception_and_then_no_exception = skip
- test_raise_through = skip
- test_raise_through_wrong_exc = skip
- test_raise_through_wrong_exc_2 = skip
- test_bridge_from_interpreter_exc = skip
- test_bridge_from_interpreter_exc_2 = skip
diff --git a/rpython/jit/backend/cli/test/test_list.py b/rpython/jit/backend/cli/test/test_list.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/test/test_list.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import py
-from rpython.jit.metainterp.test import test_list
-from rpython.jit.backend.cli.test.test_basic import CliJitMixin
-
-
-class TestVlist(CliJitMixin, test_list.TestOOtype):
- # for the individual tests see
- # ====> ../../../metainterp/test/test_list.py
-
- def skip(self):
- py.test.skip("works only after translation")
-
- test_list_pass_around = skip
- test_cannot_be_virtual = skip
- test_ll_fixed_setitem_fast = skip
diff --git a/rpython/jit/backend/cli/test/test_loop.py b/rpython/jit/backend/cli/test/test_loop.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/test/test_loop.py
+++ /dev/null
@@ -1,22 +0,0 @@
-import py
-from rpython.jit.metainterp.test import test_loop
-from rpython.jit.backend.cli.test.test_basic import CliJitMixin
-
-
-class TestLoop(CliJitMixin, test_loop.TestOOtype):
- # for the individual tests see
- # ====> ../../../metainterp/test/test_loop.py
-
- def skip(self):
- py.test.skip("works only after translation")
-
- test_loop_with_two_paths = skip
- test_interp_many_paths = skip
- test_interp_many_paths_2 = skip
- test_adapt_bridge_to_merge_point = skip
- test_outer_and_inner_loop = skip
- test_path_with_operations_not_from_start_2 = skip
- test_loop_unicode = skip
- test_loop_string = skip
- test_loop_with_delayed_setfield = skip
-
diff --git a/rpython/jit/backend/cli/test/test_runner.py b/rpython/jit/backend/cli/test/test_runner.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/test/test_runner.py
+++ /dev/null
@@ -1,76 +0,0 @@
-import py
-from rpython.jit.backend.cli.runner import CliCPU
-from rpython.jit.backend.test.runner_test import OOtypeBackendTest
-
-class FakeStats(object):
- pass
-
-# ____________________________________________________________
-
-class CliJitMixin(object):
-
- typesystem = 'ootype'
- CPUClass = CliCPU
-
- # for the individual tests see
- # ====> ../../test/runner_test.py
-
- def setup_class(cls):
- cls.cpu = cls.CPUClass(rtyper=None, stats=FakeStats())
-
-
-class TestRunner(CliJitMixin, OOtypeBackendTest):
- avoid_instances = True
-
- def skip(self):
- py.test.skip("not supported in non-translated version")
-
- test_passing_guard_class = skip # GUARD_CLASS
- test_failing_guard_class = skip # GUARD_CLASS
- test_call = skip
- test_field = skip
- test_field_basic = skip
- test_ooops = skip
- test_jump = skip
-
- def test_unused_result_float(self):
- py.test.skip('fixme! max 32 inputargs so far')
-
- def test_ovf_operations(self, reversed=False):
- self.skip()
-
- def test_do_unicode_basic(self):
- py.test.skip('fixme!')
-
- def test_unicode_basic(self):
- py.test.skip('fixme!')
-
- def test_backends_dont_keep_loops_alive(self):
- pass # the cli backend DOES keep loops alive
-
-def test_pypycliopt():
- import os
- from rpython.jit.backend.cli.method import Method
-
- def getmeth(value):
- oldenv = os.environ.get('PYPYJITOPT')
- os.environ['PYPYJITOPT'] = value
- meth = Method.__new__(Method) # evil hack not to call __init__
- meth.setoptions()
- if oldenv:
- os.environ['PYPYJITOPT'] = oldenv
- else:
- del os.environ['PYPYJITOPT']
- return meth
-
- meth = getmeth('')
- assert meth.debug == Method.debug
- assert meth.tailcall == Method.tailcall
-
- meth = getmeth('debug -tailcall')
- assert meth.debug
- assert not meth.tailcall
-
- meth = getmeth('+debug +tailcall')
- assert meth.debug
- assert meth.tailcall
diff --git a/rpython/jit/backend/cli/test/test_zrpy_basic.py b/rpython/jit/backend/cli/test/test_zrpy_basic.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/test/test_zrpy_basic.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import py
-from rpython.jit.backend.cli.runner import CliCPU
-from rpython.jit.backend.test.support import CliCompiledMixin
-from rpython.jit.metainterp.test import test_basic
-
-class CliTranslatedJitMixin(CliCompiledMixin):
- CPUClass = CliCPU
-
- def meta_interp(self, *args, **kwds):
- from rpython.rlib.jit import OPTIMIZER_SIMPLE
- kwds['optimizer'] = OPTIMIZER_SIMPLE
- return CliCompiledMixin.meta_interp(self, *args, **kwds)
-
-
-class TestBasic(CliTranslatedJitMixin, test_basic.TestOOtype):
- # for the individual tests see
- # ====> ../../../metainterp/test/test_basic.py
-
- def mono_bug(self):
- py.test.skip('mono bug?')
-
- def skip(self):
- py.test.skip('in-progress')
-
- test_stopatxpolicy = mono_bug
-
- test_print = skip
- test_bridge_from_interpreter = skip
- test_bridge_from_interpreter_2 = skip
- test_free_object = skip
-
- def test_bridge_from_interpreter_4(self):
- pass # not a translation test
-
- def test_we_are_jitted(self):
- py.test.skip("it seems to fail even with the x86 backend, didn't investigate the problem")
diff --git a/rpython/jit/backend/cli/test/test_zrpy_exception.py b/rpython/jit/backend/cli/test/test_zrpy_exception.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/test/test_zrpy_exception.py
+++ /dev/null
@@ -1,11 +0,0 @@
-import py
-from rpython.jit.backend.cli.test.test_zrpy_basic import CliTranslatedJitMixin
-from rpython.jit.metainterp.test import test_exception
-
-
-class TestException(CliTranslatedJitMixin, test_exception.TestOOtype):
- # for the individual tests see
- # ====> ../../../metainterp/test/test_exception.py
-
- pass
-
diff --git a/rpython/jit/backend/cli/test/test_zrpy_list.py b/rpython/jit/backend/cli/test/test_zrpy_list.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/test/test_zrpy_list.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import py
-from rpython.jit.backend.cli.test.test_zrpy_basic import CliTranslatedJitMixin
-from rpython.jit.metainterp.test import test_list
-
-
-class TestVList(CliTranslatedJitMixin, test_list.TestOOtype):
- # for the individual tests see
- # ====> ../../../metainterp/test/test_list.py
-
- pass
diff --git a/rpython/jit/backend/cli/test/test_zrpy_loop.py b/rpython/jit/backend/cli/test/test_zrpy_loop.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/test/test_zrpy_loop.py
+++ /dev/null
@@ -1,19 +0,0 @@
-import py
-from rpython.jit.backend.cli.test.test_zrpy_basic import CliTranslatedJitMixin
-from rpython.jit.metainterp.test import test_loop
-
-
-class TestLoop(CliTranslatedJitMixin, test_loop.TestOOtype):
- # for the individual tests see
- # ====> ../../../metainterp/test/test_loop.py
-
- def skip(self):
- py.test.skip('in-progress')
-
- def test_interp_many_paths(self):
- pass # no chance to pass it after translation, because it passes
- # non-int arguments to the function
-
- def test_interp_many_paths_2(self):
- pass # see above
-
diff --git a/rpython/jit/backend/cli/test/test_zrpy_send.py b/rpython/jit/backend/cli/test/test_zrpy_send.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/test/test_zrpy_send.py
+++ /dev/null
@@ -1,17 +0,0 @@
-import py
-from rpython.jit.backend.cli.test.test_zrpy_basic import CliTranslatedJitMixin
-from rpython.jit.metainterp.test import test_send
-
-
-class TestSend(CliTranslatedJitMixin, test_send.TestOOtype):
- # for the individual tests see
- # ====> ../../../metainterp/test/test_send.py
-
- def test_recursive_call_to_portal_from_blackhole(self):
- py.test.skip('string return values are not supported')
-
- test_oosend_guard_failure = py.test.mark.xfail(
- test_send.TestOOtype.test_oosend_guard_failure.im_func)
-
- test_oosend_guard_failure_2 = py.test.mark.xfail(
- test_send.TestOOtype.test_oosend_guard_failure_2.im_func)
diff --git a/rpython/jit/backend/cli/test/test_zrpy_slist.py b/rpython/jit/backend/cli/test/test_zrpy_slist.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/test/test_zrpy_slist.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import py
-py.test.skip('decide what to do')
-from rpython.jit.backend.cli.test.test_zrpy_basic import CliTranslatedJitMixin
-from rpython.jit.metainterp.test import test_slist
-
-
-class TestSList(CliTranslatedJitMixin, test_slist.TestOOtype):
- # for the individual tests see
- # ====> ../../../metainterp/test/test_slist.py
- pass
diff --git a/rpython/jit/backend/cli/test/test_zrpy_virtualizable.py b/rpython/jit/backend/cli/test/test_zrpy_virtualizable.py
deleted file mode 100644
--- a/rpython/jit/backend/cli/test/test_zrpy_virtualizable.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import py
-from rpython.jit.backend.cli.test.test_zrpy_basic import CliTranslatedJitMixin
-from rpython.jit.metainterp.test import test_virtualizable
-
-
-class TestVirtualizable(CliTranslatedJitMixin, test_virtualizable.TestOOtype):
- # for the individual tests see
- # ====> ../../../metainterp/test/test_virtualizable.py
-
- pass
More information about the pypy-commit
mailing list