Author: Maciej Fijalkowski <[email protected]>
Branch: optresult
Changeset: r75240:035392d23801
Date: 2015-01-05 11:04 +0200
http://bitbucket.org/pypy/pypy/changeset/035392d23801/
Log: start whacking at the backend
diff --git a/rpython/jit/backend/llsupport/regalloc.py
b/rpython/jit/backend/llsupport/regalloc.py
--- a/rpython/jit/backend/llsupport/regalloc.py
+++ b/rpython/jit/backend/llsupport/regalloc.py
@@ -734,7 +734,7 @@
# any instance field, we can use a fake object
class Fake(cls):
pass
- op = Fake(None)
+ op = Fake()
return op.is_comparison() or op.is_ovf()
def valid_addressing_size(size):
diff --git a/rpython/jit/backend/llsupport/rewrite.py
b/rpython/jit/backend/llsupport/rewrite.py
--- a/rpython/jit/backend/llsupport/rewrite.py
+++ b/rpython/jit/backend/llsupport/rewrite.py
@@ -2,8 +2,8 @@
from rpython.rlib.rarithmetic import ovfcheck
from rpython.rtyper.lltypesystem import llmemory, lltype
from rpython.jit.metainterp import history
-from rpython.jit.metainterp.history import ConstInt, BoxPtr, ConstPtr, BoxInt
-from rpython.jit.metainterp.resoperation import ResOperation, rop
+from rpython.jit.metainterp.history import ConstInt, ConstPtr
+from rpython.jit.metainterp.resoperation import ResOperation, rop, OpHelpers
from rpython.jit.codewriter import heaptracker
from rpython.jit.backend.llsupport.symbolic import WORD
from rpython.jit.backend.llsupport.descr import SizeDescr, ArrayDescr,\
@@ -96,7 +96,7 @@
elif op.getopnum() == rop.SETARRAYITEM_GC:
self.consider_setarrayitem_gc(op)
# ---------- call assembler -----------
- if op.getopnum() == rop.CALL_ASSEMBLER:
+ if OpHelpers.is_call_assembler(op.getopnum()):
self.handle_call_assembler(op)
continue
if op.getopnum() == rop.JUMP or op.getopnum() == rop.FINISH:
@@ -199,11 +199,11 @@
def handle_new_fixedsize(self, descr, op):
assert isinstance(descr, SizeDescr)
size = descr.size
- if self.gen_malloc_nursery(size, op.result):
+ if self.gen_malloc_nursery(size, op):
self.gen_initialize_tid(op.result, descr.tid)
else:
- self.gen_malloc_fixedsize(size, descr.tid, op.result)
- self.clear_gc_fields(descr, op.result)
+ self.gen_malloc_fixedsize(size, descr.tid, op)
+ self.clear_gc_fields(descr, op)
def handle_new_array(self, arraydescr, op, kind=FLAG_ARRAY):
v_length = op.getarg(0)
diff --git a/rpython/jit/backend/x86/assembler.py
b/rpython/jit/backend/x86/assembler.py
--- a/rpython/jit/backend/x86/assembler.py
+++ b/rpython/jit/backend/x86/assembler.py
@@ -1257,10 +1257,13 @@
self.mc.SET_ir(rx86.Conditions['E'], rl.value)
self.mc.MOVZX8(resloc, rl)
- def genop_same_as(self, op, arglocs, resloc):
+ def _genop_same_as(self, op, arglocs, resloc):
self.mov(arglocs[0], resloc)
- genop_cast_ptr_to_int = genop_same_as
- genop_cast_int_to_ptr = genop_same_as
+ genop_same_as_i = _genop_same_as
+ genop_same_as_r = _genop_same_as
+ genop_same_as_f = _genop_same_as
+ genop_cast_ptr_to_int = _genop_same_as
+ genop_cast_int_to_ptr = _genop_same_as
def genop_int_force_ge_zero(self, op, arglocs, resloc):
self.mc.TEST(arglocs[0], arglocs[0])
@@ -1417,17 +1420,24 @@
else:
not_implemented("save_into_mem size = %d" % size)
- def genop_getfield_gc(self, op, arglocs, resloc):
+ def _genop_getfield_gc(self, op, arglocs, resloc):
base_loc, ofs_loc, size_loc, sign_loc = arglocs
assert isinstance(size_loc, ImmedLoc)
source_addr = AddressLoc(base_loc, ofs_loc)
self.load_from_mem(resloc, source_addr, size_loc, sign_loc)
- genop_getfield_raw = genop_getfield_gc
- genop_getfield_raw_pure = genop_getfield_gc
- genop_getfield_gc_pure = genop_getfield_gc
+ genop_getfield_gc_i = _genop_getfield_gc
+ genop_getfield_gc_r = _genop_getfield_gc
+ genop_getfield_gc_f = _genop_getfield_gc
+ genop_getfield_raw_i = _genop_getfield_gc
+ genop_getfield_raw_f = _genop_getfield_gc
+ genop_getfield_raw_pure_i = _genop_getfield_gc
+ genop_getfield_raw_pure_f = _genop_getfield_gc
+ genop_getfield_gc_pure_i = _genop_getfield_gc
+ genop_getfield_gc_pure_r = _genop_getfield_gc
+ genop_getfield_gc_pure_f = _genop_getfield_gc
- def genop_getarrayitem_gc(self, op, arglocs, resloc):
+ def _genop_getarrayitem_gc(self, op, arglocs, resloc):
base_loc, ofs_loc, size_loc, ofs, sign_loc = arglocs
assert isinstance(ofs, ImmedLoc)
assert isinstance(size_loc, ImmedLoc)
@@ -1435,15 +1445,24 @@
src_addr = addr_add(base_loc, ofs_loc, ofs.value, scale)
self.load_from_mem(resloc, src_addr, size_loc, sign_loc)
- genop_getarrayitem_gc_pure = genop_getarrayitem_gc
- genop_getarrayitem_raw = genop_getarrayitem_gc
- genop_getarrayitem_raw_pure = genop_getarrayitem_gc
+ genop_getarrayitem_gc_i = _genop_getarrayitem_gc
+ genop_getarrayitem_gc_r = _genop_getarrayitem_gc
+ genop_getarrayitem_gc_f = _genop_getarrayitem_gc
+ genop_getarrayitem_gc_pure_i = _genop_getarrayitem_gc
+ genop_getarrayitem_gc_pure_r = _genop_getarrayitem_gc
+ genop_getarrayitem_gc_pure_f = _genop_getarrayitem_gc
+ genop_getarrayitem_raw_i = _genop_getarrayitem_gc
+ genop_getarrayitem_raw_f = _genop_getarrayitem_gc
+ genop_getarrayitem_raw_pure_i = _genop_getarrayitem_gc
+ genop_getarrayitem_raw_pure_f = _genop_getarrayitem_gc
- def genop_raw_load(self, op, arglocs, resloc):
+ def _genop_raw_load(self, op, arglocs, resloc):
base_loc, ofs_loc, size_loc, ofs, sign_loc = arglocs
assert isinstance(ofs, ImmedLoc)
src_addr = addr_add(base_loc, ofs_loc, ofs.value, 0)
self.load_from_mem(resloc, src_addr, size_loc, sign_loc)
+ genop_raw_load_i = _genop_raw_load
+ genop_raw_load_f = _genop_raw_load
def _imul_const_scaled(self, mc, targetreg, sourcereg, itemsize):
"""Produce one operation to do roughly
@@ -1490,13 +1509,16 @@
assert isinstance(ofs_loc, ImmedLoc)
return AddressLoc(base_loc, temp_loc, shift, ofs_loc.value)
- def genop_getinteriorfield_gc(self, op, arglocs, resloc):
+ def _genop_getinteriorfield_gc(self, op, arglocs, resloc):
(base_loc, ofs_loc, itemsize_loc, fieldsize_loc,
index_loc, temp_loc, sign_loc) = arglocs
src_addr = self._get_interiorfield_addr(temp_loc, index_loc,
itemsize_loc, base_loc,
ofs_loc)
self.load_from_mem(resloc, src_addr, fieldsize_loc, sign_loc)
+ genop_getinteriorfield_gc_i = _genop_getinteriorfield_gc
+ genop_getinteriorfield_gc_r = _genop_getinteriorfield_gc
+ genop_getinteriorfield_gc_f = _genop_getinteriorfield_gc
def genop_discard_increment_debug_counter(self, op, arglocs):
# The argument should be an immediate address. This should
@@ -1919,8 +1941,12 @@
guard_token.pos_jump_offset = self.mc.get_relative_pos() - 4
self.pending_guard_tokens.append(guard_token)
- def genop_call(self, op, arglocs, resloc):
+ def _genop_real_call(self, op, arglocs, resloc):
self._genop_call(op, arglocs, resloc)
+ genop_call_i = _genop_real_call
+ genop_call_r = _genop_real_call
+ genop_call_f = _genop_real_call
+ genop_call_n = _genop_real_call
def _genop_call(self, op, arglocs, resloc, is_call_release_gil=False):
from rpython.jit.backend.llsupport.descr import CallDescr
@@ -1955,24 +1981,32 @@
self.mc.CMP_bi(ofs, 0)
self.implement_guard(guard_token, 'NE')
- def genop_guard_call_may_force(self, op, guard_op, guard_token,
+ def _genop_guard_call_may_force(self, op, guard_op, guard_token,
arglocs, result_loc):
self._store_force_index(guard_op)
self._genop_call(op, arglocs, result_loc)
self._emit_guard_not_forced(guard_token)
+ genop_guard_call_may_force_i = _genop_guard_call_may_force
+ genop_guard_call_may_force_r = _genop_guard_call_may_force
+ genop_guard_call_may_force_f = _genop_guard_call_may_force
+ genop_guard_call_may_force_n = _genop_guard_call_may_force
- def genop_guard_call_release_gil(self, op, guard_op, guard_token,
+ def _genop_guard_call_release_gil(self, op, guard_op, guard_token,
arglocs, result_loc):
self._store_force_index(guard_op)
self._genop_call(op, arglocs, result_loc, is_call_release_gil=True)
self._emit_guard_not_forced(guard_token)
+ genop_guard_call_release_gil_i = _genop_guard_call_release_gil
+ genop_guard_call_release_gil_r = _genop_guard_call_release_gil
+ genop_guard_call_release_gil_f = _genop_guard_call_release_gil
+ genop_guard_call_release_gil_n = _genop_guard_call_release_gil
def imm(self, v):
return imm(v)
# ------------------- CALL ASSEMBLER --------------------------
- def genop_guard_call_assembler(self, op, guard_op, guard_token,
+ def _genop_guard_call_assembler(self, op, guard_op, guard_token,
arglocs, result_loc):
if len(arglocs) == 2:
[argloc, vloc] = arglocs
@@ -1981,6 +2015,10 @@
vloc = self.imm(0)
self.call_assembler(op, guard_op, argloc, vloc, result_loc, eax)
self._emit_guard_not_forced(guard_token)
+ genop_guard_call_assembler_i = _genop_guard_call_assembler
+ genop_guard_call_assembler_r = _genop_guard_call_assembler
+ genop_guard_call_assembler_f = _genop_guard_call_assembler
+ genop_guard_call_assembler_n = _genop_guard_call_assembler
def _call_assembler_emit_call(self, addr, argloc, _):
threadlocal_loc = RawEspLoc(THREADLOCAL_OFS, INT)
diff --git a/rpython/jit/backend/x86/regalloc.py
b/rpython/jit/backend/x86/regalloc.py
--- a/rpython/jit/backend/x86/regalloc.py
+++ b/rpython/jit/backend/x86/regalloc.py
@@ -23,7 +23,7 @@
from rpython.jit.codewriter.effectinfo import EffectInfo
from rpython.jit.metainterp.history import (Box, Const, ConstInt, ConstPtr,
ConstFloat, BoxInt, BoxFloat, INT, REF, FLOAT, TargetToken)
-from rpython.jit.metainterp.resoperation import rop, ResOperation
+from rpython.jit.metainterp.resoperation import rop, OpHelpers
from rpython.rlib import rgc
from rpython.rlib.objectmodel import we_are_translated
from rpython.rlib.rarithmetic import r_longlong, r_uint
@@ -757,7 +757,7 @@
[self.loc(op.getarg(i)) for i in range(op.numargs())],
guard_not_forced_op=guard_not_forced_op)
- def consider_call(self, op):
+ def _consider_real_call(self, op):
effectinfo = op.getdescr().get_extra_info()
oopspecindex = effectinfo.oopspecindex
if oopspecindex != EffectInfo.OS_NONE:
@@ -789,21 +789,37 @@
if oopspecindex == EffectInfo.OS_MATH_READ_TIMESTAMP:
return self._consider_math_read_timestamp(op)
self._consider_call(op)
+ consider_call_i = _consider_real_call
+ consider_call_r = _consider_real_call
+ consider_call_f = _consider_real_call
+ consider_call_n = _consider_real_call
- def consider_call_may_force(self, op, guard_op):
+ def _consider_call_may_force(self, op, guard_op):
assert guard_op is not None
self._consider_call(op, guard_op)
+ consider_call_may_force_i = _consider_call_may_force
+ consider_call_may_force_r = _consider_call_may_force
+ consider_call_may_force_f = _consider_call_may_force
+ consider_call_may_force_n = _consider_call_may_force
- def consider_call_release_gil(self, op, guard_op):
+ def _consider_call_release_gil(self, op, guard_op):
assert guard_op is not None
self._consider_call(op, guard_op)
-
+ consider_call_release_gil_i = _consider_call_release_gil
+ consider_call_release_gil_r = _consider_call_release_gil
+ consider_call_release_gil_f = _consider_call_release_gil
+ consider_call_release_gil_n = _consider_call_release_gil
+
def consider_call_malloc_gc(self, op):
self._consider_call(op)
- def consider_call_assembler(self, op, guard_op):
+ def _consider_call_assembler(self, op, guard_op):
locs = self.locs_for_call_assembler(op, guard_op)
self._call(op, locs, guard_not_forced_op=guard_op)
+ consider_call_assembler_i = _consider_call_assembler
+ consider_call_assembler_r = _consider_call_assembler
+ consider_call_assembler_f = _consider_call_assembler
+ consider_call_assembler_n = _consider_call_assembler
def consider_cond_call_gc_wb(self, op):
assert op.result is None
@@ -1012,7 +1028,7 @@
consider_setarrayitem_raw = consider_setarrayitem_gc
consider_raw_store = consider_setarrayitem_gc
- def consider_getfield_gc(self, op):
+ def _consider_getfield_gc(self, op):
ofs, size, sign = unpack_fielddescr(op.getdescr())
ofs_loc = imm(ofs)
size_loc = imm(size)
@@ -1025,15 +1041,22 @@
sign_loc = imm0
self.perform(op, [base_loc, ofs_loc, size_loc, sign_loc], result_loc)
- consider_getfield_raw = consider_getfield_gc
- consider_getfield_raw_pure = consider_getfield_gc
- consider_getfield_gc_pure = consider_getfield_gc
+ consider_getfield_gc_i = _consider_getfield_gc
+ consider_getfield_gc_r = _consider_getfield_gc
+ consider_getfield_gc_f = _consider_getfield_gc
+ consider_getfield_raw_i = _consider_getfield_gc
+ consider_getfield_raw_f = _consider_getfield_gc
+ consider_getfield_raw_pure_i = _consider_getfield_gc
+ consider_getfield_raw_pure_f = _consider_getfield_gc
+ consider_getfield_gc_pure_i = _consider_getfield_gc
+ consider_getfield_gc_pure_r = _consider_getfield_gc
+ consider_getfield_gc_pure_f = _consider_getfield_gc
def consider_increment_debug_counter(self, op):
base_loc = self.loc(op.getarg(0))
self.perform_discard(op, [base_loc])
- def consider_getarrayitem_gc(self, op):
+ def _consider_getarrayitem_gc(self, op):
itemsize, ofs, sign = unpack_arraydescr(op.getdescr())
args = op.getarglist()
base_loc = self.rm.make_sure_var_in_reg(op.getarg(0), args)
@@ -1046,12 +1069,20 @@
self.perform(op, [base_loc, ofs_loc, imm(itemsize), imm(ofs),
sign_loc], result_loc)
- consider_getarrayitem_raw = consider_getarrayitem_gc
- consider_getarrayitem_gc_pure = consider_getarrayitem_gc
- consider_getarrayitem_raw_pure = consider_getarrayitem_gc
- consider_raw_load = consider_getarrayitem_gc
+ consider_getarrayitem_gc_i = _consider_getarrayitem_gc
+ consider_getarrayitem_gc_r = _consider_getarrayitem_gc
+ consider_getarrayitem_gc_f = _consider_getarrayitem_gc
+ consider_getarrayitem_raw_i = _consider_getarrayitem_gc
+ consider_getarrayitem_raw_f = _consider_getarrayitem_gc
+ consider_getarrayitem_gc_pure_i = _consider_getarrayitem_gc
+ consider_getarrayitem_gc_pure_r = _consider_getarrayitem_gc
+ consider_getarrayitem_gc_pure_f = _consider_getarrayitem_gc
+ consider_getarrayitem_raw_pure_i = _consider_getarrayitem_gc
+ consider_getarrayitem_raw_pure_f = _consider_getarrayitem_gc
+ consider_raw_load_i = _consider_getarrayitem_gc
+ consider_raw_load_f = _consider_getarrayitem_gc
- def consider_getinteriorfield_gc(self, op):
+ def _consider_getinteriorfield_gc(self, op):
t = unpack_interiorfielddescr(op.getdescr())
ofs, itemsize, fieldsize, sign = imm(t[0]), imm(t[1]), imm(t[2]), t[3]
if sign:
@@ -1079,6 +1110,10 @@
self.perform(op, [base_loc, ofs, itemsize, fieldsize,
index_loc, temp_loc, sign_loc], result_loc)
+ consider_getinteriorfield_gc_i = _consider_getinteriorfield_gc
+ consider_getinteriorfield_gc_r = _consider_getinteriorfield_gc
+ consider_getinteriorfield_gc_f = _consider_getinteriorfield_gc
+
def consider_int_is_true(self, op, guard_op):
# doesn't need arg to be in a register
argloc = self.loc(op.getarg(0))
@@ -1090,12 +1125,15 @@
consider_int_is_zero = consider_int_is_true
- def consider_same_as(self, op):
+ def _consider_same_as(self, op):
argloc = self.loc(op.getarg(0))
resloc = self.force_allocate_reg(op.result)
self.perform(op, [argloc], resloc)
- consider_cast_ptr_to_int = consider_same_as
- consider_cast_int_to_ptr = consider_same_as
+ consider_cast_ptr_to_int = _consider_same_as
+ consider_cast_int_to_ptr = _consider_same_as
+ consider_same_as_i = _consider_same_as
+ consider_same_as_r = _consider_same_as
+ consider_same_as_f = _consider_same_as
def consider_int_force_ge_zero(self, op):
argloc = self.make_sure_var_in_reg(op.getarg(0))
@@ -1452,9 +1490,9 @@
name = name[len('consider_'):]
num = getattr(rop, name.upper())
if (is_comparison_or_ovf_op(num)
- or num == rop.CALL_MAY_FORCE
- or num == rop.CALL_ASSEMBLER
- or num == rop.CALL_RELEASE_GIL):
+ or OpHelpers.is_call_may_force(num)
+ or OpHelpers.is_call_assembler(num)
+ or OpHelpers.is_call_release_gil(num)):
oplist_with_guard[num] = value
oplist[num] = add_none_argument(value)
else:
diff --git a/rpython/jit/metainterp/compile.py
b/rpython/jit/metainterp/compile.py
--- a/rpython/jit/metainterp/compile.py
+++ b/rpython/jit/metainterp/compile.py
@@ -139,9 +139,9 @@
part = create_empty_loop(metainterp)
part.inputargs = inputargs[:]
h_ops = history.operations
- label = ResOperation(rop.LABEL, inputargs, None,
+ label = ResOperation(rop.LABEL, inputargs,
descr=TargetToken(jitcell_token))
- end_label = ResOperation(rop.LABEL, jumpargs, None, descr=jitcell_token)
+ end_label = ResOperation(rop.LABEL, jumpargs, descr=jitcell_token)
part.operations = [label] + h_ops[start:] + [end_label]
try:
@@ -165,7 +165,7 @@
part.operations = [part.operations[-1]] + \
[inliner.inline_op(h_ops[i]) for i in range(start,
len(h_ops))] + \
[ResOperation(rop.JUMP, [inliner.inline_arg(a) for a
in jumpargs],
- None, descr=jitcell_token)]
+ descr=jitcell_token)]
target_token = part.operations[0].getdescr()
assert isinstance(target_token, TargetToken)
all_target_tokens.append(target_token)
@@ -222,7 +222,7 @@
part.operations = [partial_trace.operations[-1]] + \
h_ops[start:] + \
- [ResOperation(rop.JUMP, jumpargs, None,
descr=loop_jitcell_token)]
+ [ResOperation(rop.JUMP, jumpargs,
descr=loop_jitcell_token)]
label = part.operations[0]
orignial_label = label.clone()
assert label.getopnum() == rop.LABEL
@@ -236,7 +236,7 @@
assert isinstance(target_token, TargetToken)
part.operations = [orignial_label] + \
[ResOperation(rop.JUMP, inputargs[:],
- None, descr=loop_jitcell_token)]
+ descr=loop_jitcell_token)]
try:
optimize_trace(metainterp_sd, jitdriver_sd, part,
jitdriver_sd.warmstate.enable_opts,
@@ -275,6 +275,7 @@
return target_token
def patch_new_loop_to_load_virtualizable_fields(loop, jitdriver_sd):
+ xxx
vinfo = jitdriver_sd.virtualizable_info
extra_ops = []
inputargs = loop.inputargs
diff --git a/rpython/jit/metainterp/optimizeopt/simplify.py
b/rpython/jit/metainterp/optimizeopt/simplify.py
--- a/rpython/jit/metainterp/optimizeopt/simplify.py
+++ b/rpython/jit/metainterp/optimizeopt/simplify.py
@@ -48,7 +48,7 @@
if not self.unroll:
descr = op.getdescr()
if isinstance(descr, JitCellToken):
- return self.optimize_JUMP(op._copy_and_change(rop.JUMP))
+ return self.optimize_JUMP(op.copy_and_change(rop.JUMP))
self.last_label_descr = op.getdescr()
self.emit_operation(op)
diff --git a/rpython/jit/metainterp/resoperation.py
b/rpython/jit/metainterp/resoperation.py
--- a/rpython/jit/metainterp/resoperation.py
+++ b/rpython/jit/metainterp/resoperation.py
@@ -1020,3 +1020,24 @@
elif tp == 'f':
return rop.CALL_F
return rop.CALL_N
+
+ @staticmethod
+ def is_call_assembler(opnum):
+ return (opnum == rop.CALL_ASSEMBLER_I or
+ opnum == rop.CALL_ASSEMBLER_R or
+ opnum == rop.CALL_ASSEMBLER_F or
+ opnum == rop.CALL_ASSEMBLER_N)
+
+ @staticmethod
+ def is_call_may_force(opnum):
+ return (opnum == rop.CALL_MAY_FORCE_I or
+ opnum == rop.CALL_MAY_FORCE_R or
+ opnum == rop.CALL_MAY_FORCE_F or
+ opnum == rop.CALL_MAY_FORCE_N)
+
+ @staticmethod
+ def is_call_release_gil(opnum):
+ return (opnum == rop.CALL_RELEASE_GIL_I or
+ opnum == rop.CALL_RELEASE_GIL_R or
+ opnum == rop.CALL_RELEASE_GIL_F or
+ opnum == rop.CALL_RELEASE_GIL_N)
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
