Author: hager <[email protected]>
Branch: ppc-jit-backend
Changeset: r51433:4c659707392a
Date: 2012-01-18 11:04 +0100
http://bitbucket.org/pypy/pypy/changeset/4c659707392a/
Log: refactored allocation of boxes
diff --git a/pypy/jit/backend/ppc/ppcgen/helper/regalloc.py
b/pypy/jit/backend/ppc/ppcgen/helper/regalloc.py
--- a/pypy/jit/backend/ppc/ppcgen/helper/regalloc.py
+++ b/pypy/jit/backend/ppc/ppcgen/helper/regalloc.py
@@ -1,5 +1,12 @@
from pypy.jit.metainterp.history import ConstInt
from pypy.rlib.objectmodel import we_are_translated
+from pypy.jit.metainterp.history import Box
+
+
+def check_imm_box(arg, size=0xFF, allow_zero=True):
+ if isinstance(arg, ConstInt):
+ return _check_imm_arg(arg.getint(), size, allow_zero)
+ return False
def _check_imm_arg(arg, size=0xFF, allow_zero=True):
#assert not isinstance(arg, ConstInt)
@@ -19,34 +26,36 @@
arg0, arg1 = boxes
imm_a0 = _check_imm_arg(arg0)
imm_a1 = _check_imm_arg(arg1)
- l0, box = self._ensure_value_is_boxed(arg0, forbidden_vars=boxes)
- boxes.append(box)
+ l0 = self._ensure_value_is_boxed(arg0, forbidden_vars=boxes)
+
if imm_a1 and not imm_a0:
l1 = self.make_sure_var_in_reg(arg1, boxes)
else:
- l1, box = self._ensure_value_is_boxed(arg1, forbidden_vars=boxes)
- boxes.append(box)
- self.possibly_free_vars(boxes)
+ l1 = self._ensure_value_is_boxed(arg1, forbidden_vars=boxes)
+
+ self.possibly_free_vars_for_op(op)
+ self.free_temp_vars()
res = self.force_allocate_reg(op.result)
- self.possibly_free_var(op.result)
+ #self.possibly_free_var(op.result)
return [l0, l1, res]
return f
def prepare_unary_cmp():
def f(self, op):
a0 = op.getarg(0)
- reg, box = self._ensure_value_is_boxed(a0)
- res = self.force_allocate_reg(op.result, [box])
- self.possibly_free_vars([a0, box, op.result])
+ assert isinstance(a0, Box)
+ reg = self.make_sure_var_in_reg(a0)
+ self.possibly_free_vars_for_op(op)
+ res = self.force_allocate_reg(op.result, [a0])
return [reg, res]
return f
def prepare_unary_int_op():
def f(self, op):
- l0, box = self._ensure_value_is_boxed(op.getarg(0))
- self.possibly_free_var(box)
+ l0 = self._ensure_value_is_boxed(op.getarg(0))
+ self.possibly_free_vars_for_op(op)
+ self.free_temp_vars()
res = self.force_allocate_reg(op.result)
- self.possibly_free_var(op.result)
return [l0, res]
return f
@@ -57,20 +66,17 @@
imm_b0 = _check_imm_arg(b0)
imm_b1 = _check_imm_arg(b1)
if not imm_b0 and imm_b1:
- l0, box = self._ensure_value_is_boxed(b0)
- l1 = self.make_sure_var_in_reg(b1, [b0])
- boxes.append(box)
+ l0 = self._ensure_value_is_boxed(b0)
+ l1 = self.make_sure_var_in_reg(b1, boxes)
elif imm_b0 and not imm_b1:
l0 = self.make_sure_var_in_reg(b0)
- l1, box = self._ensure_value_is_boxed(b1, [b0])
- boxes.append(box)
+ l1 = self._ensure_value_is_boxed(b1, boxes)
else:
- l0, box = self._ensure_value_is_boxed(b0)
- boxes.append(box)
- l1, box = self._ensure_value_is_boxed(b1, [box])
- boxes.append(box)
+ l0 = self._ensure_value_is_boxed(b0)
+ l1 = self._ensure_value_is_boxed(b1, boxes)
locs = [l0, l1]
- self.possibly_free_vars(boxes)
+ self.possibly_free_vars_for_op(op)
+ self.free_temp_vars()
res = self.force_allocate_reg(op.result)
return locs + [res]
return f
@@ -80,12 +86,9 @@
boxes = list(op.getarglist())
b0, b1 = boxes
- reg1, box = self._ensure_value_is_boxed(b0, forbidden_vars=boxes)
- boxes.append(box)
- reg2, box = self._ensure_value_is_boxed(b1, forbidden_vars=boxes)
- boxes.append(box)
+ reg1 = self._ensure_value_is_boxed(b0, forbidden_vars=boxes)
+ reg2 = self._ensure_value_is_boxed(b1, forbidden_vars=boxes)
- self.possibly_free_vars(boxes)
self.possibly_free_vars_for_op(op)
res = self.force_allocate_reg(op.result)
self.possibly_free_var(op.result)
diff --git a/pypy/jit/backend/ppc/ppcgen/opassembler.py
b/pypy/jit/backend/ppc/ppcgen/opassembler.py
--- a/pypy/jit/backend/ppc/ppcgen/opassembler.py
+++ b/pypy/jit/backend/ppc/ppcgen/opassembler.py
@@ -6,7 +6,7 @@
GPR_SAVE_AREA, BACKCHAIN_SIZE,
MAX_REG_PARAMS)
-from pypy.jit.metainterp.history import (JitCellToken, TargetToken,
+from pypy.jit.metainterp.history import (JitCellToken, TargetToken, Box,
AbstractFailDescr, FLOAT, INT, REF)
from pypy.rlib.objectmodel import we_are_translated
from pypy.jit.backend.ppc.ppcgen.helper.assembler import (count_reg_args,
@@ -704,11 +704,9 @@
def _emit_copystrcontent(self, op, regalloc, is_unicode):
# compute the source address
- args = list(op.getarglist())
- base_loc, box = regalloc._ensure_value_is_boxed(args[0], args)
- args.append(box)
- ofs_loc, box = regalloc._ensure_value_is_boxed(args[2], args)
- args.append(box)
+ args = op.getarglist()
+ base_loc = regalloc._ensure_value_is_boxed(args[0], args)
+ ofs_loc = regalloc._ensure_value_is_boxed(args[2], args)
assert args[0] is not args[1] # forbidden case of aliasing
regalloc.possibly_free_var(args[0])
if args[3] is not args[2] is not args[4]: # MESS MESS MESS: don't free
@@ -724,41 +722,44 @@
dstaddr_box = TempPtr()
dstaddr_loc = regalloc.force_allocate_reg(dstaddr_box)
forbidden_vars.append(dstaddr_box)
- base_loc, box = regalloc._ensure_value_is_boxed(args[1],
forbidden_vars)
- args.append(box)
- forbidden_vars.append(box)
- ofs_loc, box = regalloc._ensure_value_is_boxed(args[3], forbidden_vars)
- args.append(box)
+ base_loc = regalloc._ensure_value_is_boxed(args[1], forbidden_vars)
+ ofs_loc = regalloc._ensure_value_is_boxed(args[3], forbidden_vars)
assert base_loc.is_reg()
assert ofs_loc.is_reg()
regalloc.possibly_free_var(args[1])
if args[3] is not args[4]: # more of the MESS described above
regalloc.possibly_free_var(args[3])
+ regalloc.free_temp_vars()
self._gen_address_inside_string(base_loc, ofs_loc, dstaddr_loc,
is_unicode=is_unicode)
# compute the length in bytes
forbidden_vars = [srcaddr_box, dstaddr_box]
- length_loc, length_box = regalloc._ensure_value_is_boxed(args[4],
forbidden_vars)
- args.append(length_box)
+ if isinstance(args[4], Box):
+ length_box = args[4]
+ length_loc = regalloc.make_sure_var_in_reg(args[4], forbidden_vars)
+ else:
+ length_box = TempInt()
+ length_loc = regalloc.force_allocate_reg(length_box,
forbidden_vars)
+ imm = regalloc.convert_to_imm(args[4])
+ self.load(length_loc, imm)
if is_unicode:
- forbidden_vars = [srcaddr_box, dstaddr_box]
bytes_box = TempPtr()
bytes_loc = regalloc.force_allocate_reg(bytes_box, forbidden_vars)
scale = self._get_unicode_item_scale()
assert length_loc.is_reg()
- self.mc.li(r.r0.value, 1<<scale)
+ self.mc.alloc_scratch_reg(1 << scale)
if IS_PPC_32:
- self.mc.mullw(bytes_loc.value, r.r0.value, length_loc.value)
+ self.mc.mullw(bytes_loc.value, r.SCRATCH.value,
length_loc.value)
else:
- self.mc.mulld(bytes_loc.value, r.r0.value, length_loc.value)
+ self.mc.mulld(bytes_loc.value, r.SCRATCH.value,
length_loc.value)
+ self.mc.free_scratch_reg()
length_box = bytes_box
length_loc = bytes_loc
# call memcpy()
self._emit_call(NO_FORCE_INDEX, self.memcpy_addr,
[dstaddr_box, srcaddr_box, length_box], regalloc)
- regalloc.possibly_free_vars(args)
regalloc.possibly_free_var(length_box)
regalloc.possibly_free_var(dstaddr_box)
regalloc.possibly_free_var(srcaddr_box)
diff --git a/pypy/jit/backend/ppc/ppcgen/ppc_assembler.py
b/pypy/jit/backend/ppc/ppcgen/ppc_assembler.py
--- a/pypy/jit/backend/ppc/ppcgen/ppc_assembler.py
+++ b/pypy/jit/backend/ppc/ppcgen/ppc_assembler.py
@@ -582,6 +582,8 @@
arglocs = regalloc.operations[opnum](regalloc, op)
if arglocs is not None:
self.operations[opnum](self, op, arglocs, regalloc)
+ if op.is_guard():
+ regalloc.possibly_free_vars(op.getfailargs())
if op.result:
regalloc.possibly_free_var(op.result)
regalloc.possibly_free_vars_for_op(op)
diff --git a/pypy/jit/backend/ppc/ppcgen/regalloc.py
b/pypy/jit/backend/ppc/ppcgen/regalloc.py
--- a/pypy/jit/backend/ppc/ppcgen/regalloc.py
+++ b/pypy/jit/backend/ppc/ppcgen/regalloc.py
@@ -4,7 +4,8 @@
from pypy.jit.backend.ppc.ppcgen.jump import (remap_frame_layout_mixed,
remap_frame_layout)
from pypy.jit.backend.ppc.ppcgen.locations import imm
-from pypy.jit.backend.ppc.ppcgen.helper.regalloc import (_check_imm_arg,
+from pypy.jit.backend.ppc.ppcgen.helper.regalloc import (_check_imm_arg,
+ check_imm_box,
prepare_cmp_op,
prepare_unary_int_op,
prepare_binary_int_op,
@@ -95,6 +96,22 @@
assert isinstance(c, ConstPtr)
return locations.ImmLocation(rffi.cast(lltype.Signed, c.value))
+ def ensure_value_is_boxed(self, thing, forbidden_vars=None):
+ loc = None
+ if isinstance(thing, Const):
+ if isinstance(thing, ConstPtr):
+ tp = REF
+ else:
+ tp = INT
+ loc = self.get_scratch_reg(tp, forbidden_vars=self.temp_boxes
+ + forbidden_vars)
+ immvalue = self.convert_to_imm(thing)
+ self.assembler.load(loc, immvalue)
+ else:
+ loc = self.make_sure_var_in_reg(thing,
+ forbidden_vars=forbidden_vars)
+ return loc
+
def allocate_scratch_reg(self, type=INT, selected_reg=None,
forbidden_vars=None):
"""Allocate a scratch register, possibly spilling a managed register.
This register is freed after emitting the current operation and can not
@@ -279,21 +296,10 @@
return self.rm.call_result_location(v)
def _ensure_value_is_boxed(self, thing, forbidden_vars=[]):
- box = None
- loc = None
- if isinstance(thing, Const):
- if isinstance(thing, ConstPtr):
- box = TempPtr()
- else:
- box = TempInt()
- loc = self.force_allocate_reg(box, forbidden_vars=forbidden_vars)
- imm = self.rm.convert_to_imm(thing)
- self.assembler.mc.load_imm(loc, imm.value)
+ if thing.type == FLOAT:
+ assert 0, "not implemented yet"
else:
- loc = self.make_sure_var_in_reg(thing,
- forbidden_vars=forbidden_vars)
- box = thing
- return loc, box
+ return self.rm.ensure_value_is_boxed(thing, forbidden_vars)
def get_scratch_reg(self, type, forbidden_vars=[], selected_reg=None):
if type == FLOAT:
@@ -309,9 +315,15 @@
if var.type == FLOAT:
assert 0, "not implemented yet"
else:
- return self.rm.make_sure_var_in_reg(var, forbidden_vars,
+ return self.rm.make_sure_var_in_reg(var, forbidden_vars,
selected_reg, need_lower_byte)
+ def convert_to_imm(self, value):
+ if isinstance(value, ConstInt):
+ return self.rm.convert_to_imm(value)
+ else:
+ assert 0, "not implemented yet"
+
def _sync_var(self, v):
if v.type == FLOAT:
assert 0, "not implemented yet"
@@ -395,10 +407,8 @@
return args
def prepare_guard_true(self, op):
- l0, box = self._ensure_value_is_boxed(op.getarg(0))
+ l0 = self._ensure_value_is_boxed(op.getarg(0))
args = self._prepare_guard(op, [l0])
- self.possibly_free_var(box)
- self.possibly_free_vars(op.getfailargs())
return args
prepare_guard_false = prepare_guard_true
@@ -416,68 +426,51 @@
def prepare_guard_exception(self, op):
boxes = list(op.getarglist())
arg0 = ConstInt(rffi.cast(lltype.Signed, op.getarg(0).getint()))
- loc, box = self._ensure_value_is_boxed(arg0)
- boxes.append(box)
- box = TempInt()
- loc1 = self.force_allocate_reg(box, boxes)
- boxes.append(box)
+ loc = self._ensure_value_is_boxed(arg0)
+ loc1 = self.get_scratch_reg(INT, boxes)
if op.result in self.longevity:
resloc = self.force_allocate_reg(op.result, boxes)
- boxes.append(op.result)
+ self.possibly_free_var(op.result)
else:
resloc = None
pos_exc_value = imm(self.cpu.pos_exc_value())
pos_exception = imm(self.cpu.pos_exception())
- arglocs = self._prepare_guard(op, [loc, loc1, resloc, pos_exc_value,
pos_exception])
- self.possibly_free_vars(boxes)
- self.possibly_free_vars(op.getfailargs())
+ arglocs = self._prepare_guard(op,
+ [loc, loc1, resloc, pos_exc_value, pos_exception])
return arglocs
def prepare_guard_no_exception(self, op):
- loc, box = self._ensure_value_is_boxed(
+ loc = self._ensure_value_is_boxed(
ConstInt(self.cpu.pos_exception()))
arglocs = self._prepare_guard(op, [loc])
- self.possibly_free_var(box)
- self.possibly_free_vars(op.getfailargs())
return arglocs
def prepare_guard_value(self, op):
boxes = list(op.getarglist())
- b0, b1 = boxes
- imm_b1 = _check_imm_arg(b1)
- l0, box = self._ensure_value_is_boxed(b0, boxes)
- boxes.append(box)
- if not imm_b1:
- l1, box = self._ensure_value_is_boxed(b1,boxes)
- boxes.append(box)
+ a0, a1 = boxes
+ imm_a1 = check_imm_box(a1)
+ l0 = self._ensure_value_is_boxed(a0, boxes)
+ if not imm_a1:
+ l1 = self._ensure_value_is_boxed(a1, boxes)
else:
- l1 = self.make_sure_var_in_reg(b1)
+ l1 = self.make_sure_var_in_reg(a1, boxes)
assert op.result is None
arglocs = self._prepare_guard(op, [l0, l1])
- self.possibly_free_vars(boxes)
+ self.possibly_free_vars(op.getarglist())
self.possibly_free_vars(op.getfailargs())
return arglocs
def prepare_guard_class(self, op):
assert isinstance(op.getarg(0), Box)
boxes = list(op.getarglist())
-
- x, x_box = self._ensure_value_is_boxed(boxes[0], boxes)
- boxes.append(x_box)
-
- t = TempInt()
- y = self.force_allocate_reg(t, boxes)
- boxes.append(t)
+ x = self._ensure_value_is_boxed(boxes[0], boxes)
+ y = self.get_scratch_reg(REF, forbidden_vars=boxes)
y_val = rffi.cast(lltype.Signed, op.getarg(1).getint())
- self.assembler.mc.load_imm(y, y_val)
-
+ self.assembler.load(y, imm(y_val))
offset = self.cpu.vtable_offset
assert offset is not None
- offset_loc, offset_box = self._ensure_value_is_boxed(ConstInt(offset),
boxes)
- boxes.append(offset_box)
+ offset_loc = self._ensure_value_is_boxed(ConstInt(offset), boxes)
arglocs = self._prepare_guard(op, [x, y, offset_loc])
- self.possibly_free_vars(boxes)
- self.possibly_free_vars(op.getfailargs())
return arglocs
prepare_guard_nonnull_class = prepare_guard_class
@@ -568,37 +561,32 @@
def prepare_setfield_gc(self, op):
boxes = list(op.getarglist())
- b0, b1 = boxes
- ofs, size, ptr = unpack_fielddescr(op.getdescr())
- base_loc, base_box = self._ensure_value_is_boxed(b0, boxes)
- boxes.append(base_box)
- value_loc, value_box = self._ensure_value_is_boxed(b1, boxes)
- boxes.append(value_box)
- c_ofs = ConstInt(ofs)
- if _check_imm_arg(c_ofs):
+ a0, a1 = boxes
+ ofs, size, sign = unpack_fielddescr(op.getdescr())
+ base_loc = self._ensure_value_is_boxed(a0, boxes)
+ value_loc = self._ensure_value_is_boxed(a1, boxes)
+ if _check_imm_arg(ofs):
ofs_loc = imm(ofs)
else:
- ofs_loc, ofs_box = self._ensure_value_is_boxed(c_ofs, boxes)
- boxes.append(ofs_box)
- self.possibly_free_vars(boxes)
+ ofs_loc = self.get_scratch_reg(INT, boxes)
+ self.assembler.load(ofs_loc, imm(ofs))
return [value_loc, base_loc, ofs_loc, imm(size)]
prepare_setfield_raw = prepare_setfield_gc
def prepare_getfield_gc(self, op):
a0 = op.getarg(0)
- ofs, size, ptr = unpack_fielddescr(op.getdescr())
- base_loc, base_box = self._ensure_value_is_boxed(a0)
- c_ofs = ConstInt(ofs)
- if _check_imm_arg(c_ofs):
- ofs_loc = imm(ofs)
+ ofs, size, sign = unpack_fielddescr(op.getdescr())
+ base_loc = self._ensure_value_is_boxed(a0)
+ immofs = imm(ofs)
+ if _check_imm_arg(ofs):
+ ofs_loc = immofs
else:
- ofs_loc, ofs_box = self._ensure_value_is_boxed(c_ofs, [base_box])
- self.possibly_free_var(ofs_box)
- self.possibly_free_var(a0)
- self.possibly_free_var(base_box)
+ ofs_loc = self.get_scratch_reg(INT, [a0])
+ self.assembler.load(ofs_loc, immofs)
+ self.possibly_free_vars_for_op(op)
+ self.free_temp_vars()
res = self.force_allocate_reg(op.result)
- self.possibly_free_var(op.result)
return [base_loc, ofs_loc, res, imm(size)]
prepare_getfield_raw = prepare_getfield_gc
@@ -650,11 +638,10 @@
assert isinstance(arraydescr, ArrayDescr)
ofs = arraydescr.lendescr.offset
arg = op.getarg(0)
- base_loc, base_box = self._ensure_value_is_boxed(arg)
- self.possibly_free_vars([arg, base_box])
-
+ base_loc = self._ensure_value_is_boxed(arg)
+ self.possibly_free_vars_for_op(op)
+ self.free_temp_vars()
res = self.force_allocate_reg(op.result)
- self.possibly_free_var(op.result)
return [res, base_loc, imm(ofs)]
def prepare_setarrayitem_gc(self, op):
@@ -662,17 +649,13 @@
size, ofs, _ = unpack_arraydescr(op.getdescr())
scale = get_scale(size)
args = op.getarglist()
- base_loc, base_box = self._ensure_value_is_boxed(a0, args)
- ofs_loc, ofs_box = self._ensure_value_is_boxed(a1, args)
- value_loc, value_box = self._ensure_value_is_boxed(a2, args)
+ base_loc = self._ensure_value_is_boxed(a0, args)
+ ofs_loc = self._ensure_value_is_boxed(a1, args)
+ scratch_loc = self.rm.get_scratch_reg(INT, [base_loc, ofs_loc])
+ value_loc = self._ensure_value_is_boxed(a2, args)
assert _check_imm_arg(ofs)
- scratch_loc = self.rm.get_scratch_reg(INT, [base_loc, ofs_loc])
- self.possibly_free_var(base_box)
- self.possibly_free_var(ofs_box)
- self.possibly_free_var(value_box)
- assert scratch_loc not in [base_loc, ofs_loc]
- return [value_loc, base_loc, ofs_loc,
- scratch_loc, imm(scale), imm(ofs)]
+ return [value_loc, base_loc, ofs_loc, scratch_loc,
+ imm(scale), imm(ofs)]
prepare_setarrayitem_raw = prepare_setarrayitem_gc
@@ -680,58 +663,52 @@
a0, a1 = boxes = list(op.getarglist())
size, ofs, _ = unpack_arraydescr(op.getdescr())
scale = get_scale(size)
- base_loc, base_box = self._ensure_value_is_boxed(a0, boxes)
- boxes.append(base_box)
- ofs_loc, ofs_box = self._ensure_value_is_boxed(a1, boxes)
- boxes.append(ofs_box)
+ base_loc = self._ensure_value_is_boxed(a0, boxes)
+ ofs_loc = self._ensure_value_is_boxed(a1, boxes)
scratch_loc = self.rm.get_scratch_reg(INT, [base_loc, ofs_loc])
- assert scratch_loc not in [base_loc, ofs_loc]
- self.possibly_free_vars(boxes)
+ self.possibly_free_vars_for_op(op)
+ self.free_temp_vars()
res = self.force_allocate_reg(op.result)
- self.possibly_free_var(op.result)
assert _check_imm_arg(ofs)
- return [res, base_loc, ofs_loc,
- scratch_loc, imm(scale), imm(ofs)]
+ return [res, base_loc, ofs_loc, scratch_loc,
+ imm(scale), imm(ofs)]
prepare_getarrayitem_raw = prepare_getarrayitem_gc
prepare_getarrayitem_gc_pure = prepare_getarrayitem_gc
def prepare_strlen(self, op):
- l0, box = self._ensure_value_is_boxed(op.getarg(0))
- boxes = [box]
-
+ args = op.getarglist()
+ l0 = self._ensure_value_is_boxed(op.getarg(0))
basesize, itemsize, ofs_length = symbolic.get_array_token(rstr.STR,
self.cpu.translate_support_code)
- ofs_box = ConstInt(ofs_length)
- imm_ofs = _check_imm_arg(ofs_box)
+ immofs = imm(ofs_length)
+ if _check_imm_arg(ofs_length):
+ l1 = immofs
+ else:
+ l1 = self.get_scratch_reg(INT, args)
+ self.assembler.load(l1, immofs)
- if imm_ofs:
- l1 = self.make_sure_var_in_reg(ofs_box, boxes)
- else:
- l1, box1 = self._ensure_value_is_boxed(ofs_box, boxes)
- boxes.append(box1)
+ self.possibly_free_vars_for_op(op)
+ self.free_temp_vars()
- self.possibly_free_vars(boxes)
res = self.force_allocate_reg(op.result)
self.possibly_free_var(op.result)
return [l0, l1, res]
def prepare_strgetitem(self, op):
boxes = list(op.getarglist())
- base_loc, box = self._ensure_value_is_boxed(boxes[0])
- boxes.append(box)
+ base_loc = self._ensure_value_is_boxed(boxes[0])
a1 = boxes[1]
- imm_a1 = _check_imm_arg(a1)
+ imm_a1 = check_imm_box(a1)
if imm_a1:
ofs_loc = self.make_sure_var_in_reg(a1, boxes)
else:
- ofs_loc, box = self._ensure_value_is_boxed(a1, boxes)
- boxes.append(box)
+ ofs_loc = self._ensure_value_is_boxed(a1, boxes)
- self.possibly_free_vars(boxes)
+ self.possibly_free_vars_for_op(op)
+ self.free_temp_vars()
res = self.force_allocate_reg(op.result)
- self.possibly_free_var(op.result)
basesize, itemsize, ofs_length = symbolic.get_array_token(rstr.STR,
self.cpu.translate_support_code)
@@ -740,18 +717,9 @@
def prepare_strsetitem(self, op):
boxes = list(op.getarglist())
-
- base_loc, box = self._ensure_value_is_boxed(boxes[0], boxes)
- boxes.append(box)
-
- ofs_loc, box = self._ensure_value_is_boxed(boxes[1], boxes)
- boxes.append(box)
-
- value_loc, box = self._ensure_value_is_boxed(boxes[2], boxes)
- boxes.append(box)
-
- self.possibly_free_vars(boxes)
-
+ base_loc = self._ensure_value_is_boxed(boxes[0], boxes)
+ ofs_loc = self._ensure_value_is_boxed(boxes[1], boxes)
+ value_loc = self._ensure_value_is_boxed(boxes[2], boxes)
basesize, itemsize, ofs_length = symbolic.get_array_token(rstr.STR,
self.cpu.translate_support_code)
assert itemsize == 1
@@ -761,55 +729,46 @@
prepare_copyunicodecontent = void
def prepare_unicodelen(self, op):
- l0, box = self._ensure_value_is_boxed(op.getarg(0))
- boxes = [box]
+ l0 = self._ensure_value_is_boxed(op.getarg(0))
basesize, itemsize, ofs_length = symbolic.get_array_token(rstr.UNICODE,
self.cpu.translate_support_code)
- ofs_box = ConstInt(ofs_length)
- imm_ofs = _check_imm_arg(ofs_box)
+ immofs = imm(ofs_length)
+ if _check_imm_arg(ofs_length):
+ l1 = immofs
+ else:
+ l1 = self.get_scratch_reg(INT, [op.getarg(0)])
+ self.assembler.load(l1, immofs)
- if imm_ofs:
- l1 = imm(ofs_length)
- else:
- l1, box1 = self._ensure_value_is_boxed(ofs_box, boxes)
- boxes.append(box1)
-
- self.possibly_free_vars(boxes)
+ self.possibly_free_vars_for_op(op)
+ self.free_temp_vars()
res = self.force_allocate_reg(op.result)
- self.possibly_free_var(op.result)
return [l0, l1, res]
def prepare_unicodegetitem(self, op):
boxes = list(op.getarglist())
- base_loc, box = self._ensure_value_is_boxed(boxes[0], boxes)
- boxes.append(box)
- ofs_loc, box = self._ensure_value_is_boxed(boxes[1], boxes)
- boxes.append(box)
- self.possibly_free_vars(boxes)
+ base_loc = self._ensure_value_is_boxed(boxes[0], boxes)
+ ofs_loc = self._ensure_value_is_boxed(boxes[1], boxes)
+ self.possibly_free_vars_for_op(op)
+ self.free_temp_vars()
res = self.force_allocate_reg(op.result)
- self.possibly_free_var(op.result)
basesize, itemsize, ofs_length = symbolic.get_array_token(rstr.UNICODE,
self.cpu.translate_support_code)
- scale = itemsize/2
- return [res, base_loc, ofs_loc, imm(scale), imm(basesize),
imm(itemsize)]
+ scale = itemsize / 2
+ return [res, base_loc, ofs_loc,
+ imm(scale), imm(basesize), imm(itemsize)]
def prepare_unicodesetitem(self, op):
boxes = list(op.getarglist())
- base_loc, box = self._ensure_value_is_boxed(boxes[0], boxes)
- boxes.append(box)
- ofs_loc, box = self._ensure_value_is_boxed(boxes[1], boxes)
- boxes.append(box)
- value_loc, box = self._ensure_value_is_boxed(boxes[2], boxes)
- boxes.append(box)
-
- self.possibly_free_vars(boxes)
-
+ base_loc = self._ensure_value_is_boxed(boxes[0], boxes)
+ ofs_loc = self._ensure_value_is_boxed(boxes[1], boxes)
+ value_loc = self._ensure_value_is_boxed(boxes[2], boxes)
basesize, itemsize, ofs_length = symbolic.get_array_token(rstr.UNICODE,
self.cpu.translate_support_code)
- scale = itemsize/2
- return [value_loc, base_loc, ofs_loc, imm(scale), imm(basesize),
imm(itemsize)]
+ scale = itemsize / 2
+ return [value_loc, base_loc, ofs_loc,
+ imm(scale), imm(basesize), imm(itemsize)]
def prepare_same_as(self, op):
arg = op.getarg(0)
@@ -817,11 +776,10 @@
if imm_arg:
argloc = self.make_sure_var_in_reg(arg)
else:
- argloc, box = self._ensure_value_is_boxed(arg)
- self.possibly_free_var(box)
-
+ argloc = self._ensure_value_is_boxed(arg)
+ self.possibly_free_vars_for_op(op)
+ self.free_temp_vars()
resloc = self.force_allocate_reg(op.result)
- self.possibly_free_var(op.result)
return [argloc, resloc]
prepare_cast_ptr_to_int = prepare_same_as
@@ -850,9 +808,8 @@
arglocs = []
argboxes = []
for i in range(N):
- loc, box = self._ensure_value_is_boxed(op.getarg(i), argboxes)
+ loc = self._ensure_value_is_boxed(op.getarg(i), argboxes)
arglocs.append(loc)
- argboxes.append(box)
self.rm.possibly_free_vars(argboxes)
return arglocs
_______________________________________________
pypy-commit mailing list
[email protected]
http://mail.python.org/mailman/listinfo/pypy-commit
