Author: Armin Rigo <[email protected]>
Branch: op_malloc_gc
Changeset: r50676:b21c37068b7c
Date: 2011-12-18 19:03 +0100
http://bitbucket.org/pypy/pypy/changeset/b21c37068b7c/
Log: Start to kill stuff in the x86 backend :-)
diff --git a/pypy/jit/backend/llsupport/descr.py
b/pypy/jit/backend/llsupport/descr.py
--- a/pypy/jit/backend/llsupport/descr.py
+++ b/pypy/jit/backend/llsupport/descr.py
@@ -91,6 +91,9 @@
def is_pointer_field(self):
return self.flag == FLAG_POINTER
+ def is_float_field(self):
+ return self.flag == FLAG_FLOAT
+
def is_field_signed(self):
return self.flag == FLAG_SIGNED
@@ -163,9 +166,15 @@
def is_array_of_pointers(self):
return self.flag == FLAG_POINTER
+ def is_array_of_floats(self):
+ return self.flag == FLAG_FLOAT
+
def is_item_signed(self):
return self.flag == FLAG_SIGNED
+ def is_array_of_structs(self):
+ return self.flag == FLAG_STRUCT
+
def repr_of_descr(self):
return '<Array%s %s>' % (self.flag, self.itemsize)
@@ -208,6 +217,12 @@
def sort_key(self):
return self.fielddescr.sort_key()
+ def is_pointer_field(self):
+ return self.fielddescr.is_pointer_field()
+
+ def is_float_field(self):
+ return self.fielddescr.is_float_field()
+
def repr_of_descr(self):
return '<InteriorFieldDescr %s>' % self.fielddescr.repr_of_descr()
diff --git a/pypy/jit/backend/llsupport/gc.py b/pypy/jit/backend/llsupport/gc.py
--- a/pypy/jit/backend/llsupport/gc.py
+++ b/pypy/jit/backend/llsupport/gc.py
@@ -111,6 +111,7 @@
fielddescr_tid = None
str_type_id = 0
unicode_type_id = 0
+ get_malloc_slowpath_addr = None
@classmethod
def configure_boehm_once(cls):
@@ -837,6 +838,9 @@
def freeing_block(self, start, stop):
self.gcrootmap.freeing_block(start, stop)
+ def get_malloc_slowpath_addr(self):
+ return self.c_malloc_nursery_fn.value
+
# ____________________________________________________________
def get_ll_description(gcdescr, translator=None, rtyper=None):
diff --git a/pypy/jit/backend/x86/assembler.py
b/pypy/jit/backend/x86/assembler.py
--- a/pypy/jit/backend/x86/assembler.py
+++ b/pypy/jit/backend/x86/assembler.py
@@ -70,10 +70,6 @@
self.cpu = cpu
self.verbose = False
self.rtyper = cpu.rtyper
- self.malloc_func_addr = 0
- self.malloc_array_func_addr = 0
- self.malloc_str_func_addr = 0
- self.malloc_unicode_func_addr = 0
self.fail_boxes_int = values_array(lltype.Signed, failargs_limit)
self.fail_boxes_ptr = values_array(llmemory.GCREF, failargs_limit)
self.fail_boxes_float = values_array(longlong.FLOATSTORAGE,
@@ -108,20 +104,6 @@
# the address of the function called by 'new'
gc_ll_descr = self.cpu.gc_ll_descr
gc_ll_descr.initialize()
- ll_new = gc_ll_descr.get_funcptr_for_new()
- self.malloc_func_addr = rffi.cast(lltype.Signed, ll_new)
- if gc_ll_descr.get_funcptr_for_newarray is not None:
- ll_new_array = gc_ll_descr.get_funcptr_for_newarray()
- self.malloc_array_func_addr = rffi.cast(lltype.Signed,
- ll_new_array)
- if gc_ll_descr.get_funcptr_for_newstr is not None:
- ll_new_str = gc_ll_descr.get_funcptr_for_newstr()
- self.malloc_str_func_addr = rffi.cast(lltype.Signed,
- ll_new_str)
- if gc_ll_descr.get_funcptr_for_newunicode is not None:
- ll_new_unicode = gc_ll_descr.get_funcptr_for_newunicode()
- self.malloc_unicode_func_addr = rffi.cast(lltype.Signed,
- ll_new_unicode)
self.memcpy_addr = self.cpu.cast_ptr_to_int(support.memcpy_fn)
self._build_failure_recovery(False)
self._build_failure_recovery(True)
@@ -1357,46 +1339,10 @@
self.mc.SHR_ri(resloc.value, 7)
self.mc.AND_ri(resloc.value, 1)
- def genop_new_with_vtable(self, op, arglocs, result_loc):
- assert result_loc is eax
- loc_vtable = arglocs[-1]
- assert isinstance(loc_vtable, ImmedLoc)
- arglocs = arglocs[:-1]
- self.call(self.malloc_func_addr, arglocs, eax)
- self.propagate_memoryerror_if_eax_is_null()
- self.set_vtable(eax, loc_vtable)
+ # ----------
- def set_vtable(self, loc, loc_vtable):
- if self.cpu.vtable_offset is not None:
- assert isinstance(loc, RegLoc)
- assert isinstance(loc_vtable, ImmedLoc)
- self.mc.MOV(mem(loc, self.cpu.vtable_offset), loc_vtable)
-
- def set_new_array_length(self, loc, ofs_length, loc_num_elem):
- assert isinstance(loc, RegLoc)
- assert isinstance(loc_num_elem, ImmedLoc)
- self.mc.MOV(mem(loc, ofs_length), loc_num_elem)
-
- # XXX genop_new is abused for all varsized mallocs with Boehm, for now
- # (instead of genop_new_array, genop_newstr, genop_newunicode)
- def genop_new(self, op, arglocs, result_loc):
- assert result_loc is eax
- self.call(self.malloc_func_addr, arglocs, eax)
- self.propagate_memoryerror_if_eax_is_null()
-
- def genop_new_array(self, op, arglocs, result_loc):
- assert result_loc is eax
- self.call(self.malloc_array_func_addr, arglocs, eax)
- self.propagate_memoryerror_if_eax_is_null()
-
- def genop_newstr(self, op, arglocs, result_loc):
- assert result_loc is eax
- self.call(self.malloc_str_func_addr, arglocs, eax)
- self.propagate_memoryerror_if_eax_is_null()
-
- def genop_newunicode(self, op, arglocs, result_loc):
- assert result_loc is eax
- self.call(self.malloc_unicode_func_addr, arglocs, eax)
+ def genop_call_malloc_gc(self, op, arglocs, result_loc):
+ self.genop_call(op, arglocs, result_loc)
self.propagate_memoryerror_if_eax_is_null()
def propagate_memoryerror_if_eax_is_null(self):
@@ -2065,6 +2011,8 @@
self._genop_call(op, arglocs, resloc, force_index)
def _genop_call(self, op, arglocs, resloc, force_index):
+ from pypy.jit.backend.llsupport.descr import CallDescr
+
sizeloc = arglocs[0]
assert isinstance(sizeloc, ImmedLoc)
size = sizeloc.value
@@ -2079,13 +2027,16 @@
else:
tmp = eax
+ descr = op.getdescr()
+ assert isinstance(descr, CallDescr)
+
self._emit_call(force_index, x, arglocs, 3, tmp=tmp,
- argtypes=op.getdescr().get_arg_types(),
- callconv=op.getdescr().get_call_conv())
+ argtypes=descr.get_arg_types(),
+ callconv=descr.get_call_conv())
if IS_X86_32 and isinstance(resloc, StackLoc) and resloc.type == FLOAT:
# a float or a long long return
- if op.getdescr().get_return_type() == 'L':
+ if descr.get_result_type() == 'L':
self.mc.MOV_br(resloc.value, eax.value) # long long
self.mc.MOV_br(resloc.value + 4, edx.value)
# XXX should ideally not move the result on the stack,
@@ -2094,7 +2045,7 @@
# can just be always a stack location
else:
self.mc.FSTPL_b(resloc.value) # float return
- elif op.getdescr().get_return_type() == 'S':
+ elif descr.get_result_type() == 'S':
# singlefloat return
assert resloc is eax
if IS_X86_32:
diff --git a/pypy/jit/backend/x86/regalloc.py b/pypy/jit/backend/x86/regalloc.py
--- a/pypy/jit/backend/x86/regalloc.py
+++ b/pypy/jit/backend/x86/regalloc.py
@@ -16,8 +16,8 @@
from pypy.jit.codewriter import heaptracker, longlong
from pypy.jit.codewriter.effectinfo import EffectInfo
from pypy.jit.metainterp.resoperation import rop
-from pypy.jit.backend.llsupport.descr import BaseFieldDescr, BaseArrayDescr
-from pypy.jit.backend.llsupport.descr import BaseCallDescr, BaseSizeDescr
+from pypy.jit.backend.llsupport.descr import FieldDescr, ArrayDescr
+from pypy.jit.backend.llsupport.descr import CallDescr, SizeDescr
from pypy.jit.backend.llsupport.descr import InteriorFieldDescr
from pypy.jit.backend.llsupport.regalloc import FrameManager, RegisterManager,\
TempBox
@@ -870,9 +870,9 @@
def _consider_call(self, op, guard_not_forced_op=None):
calldescr = op.getdescr()
- assert isinstance(calldescr, BaseCallDescr)
+ assert isinstance(calldescr, CallDescr)
assert len(calldescr.arg_classes) == op.numargs() - 1
- size = calldescr.get_result_size(self.translate_support_code)
+ size = calldescr.get_result_size()
sign = calldescr.is_result_signed()
if sign:
sign_loc = imm1
@@ -917,12 +917,15 @@
consider_call_release_gil = consider_call_may_force
+ def consider_call_malloc_gc(self, op):
+ self._consider_call(op)
+
def consider_call_assembler(self, op, guard_op):
descr = op.getdescr()
assert isinstance(descr, JitCellToken)
jd = descr.outermost_jitdriver_sd
assert jd is not None
- size = jd.portal_calldescr.get_result_size(self.translate_support_code)
+ size = jd.portal_calldescr.get_result_size()
vable_index = jd.index_of_virtualizable
if vable_index >= 0:
self.rm._sync_var(op.getarg(vable_index))
@@ -958,10 +961,12 @@
consider_cond_call_gc_wb_array = consider_cond_call_gc_wb
def fastpath_malloc_fixedsize(self, op, descr):
- assert isinstance(descr, BaseSizeDescr)
+ KILLME
+ assert isinstance(descr, SizeDescr)
self._do_fastpath_malloc(op, descr.size, descr.tid)
def fastpath_malloc_varsize(self, op, arraydescr, num_elem):
+ KILLME
assert isinstance(arraydescr, BaseArrayDescr)
ofs_length = arraydescr.get_ofs_length(self.translate_support_code)
basesize = arraydescr.get_base_size(self.translate_support_code)
@@ -971,6 +976,7 @@
self.assembler.set_new_array_length(eax, ofs_length, imm(num_elem))
def _do_fastpath_malloc(self, op, size, tid):
+ KILLME
gc_ll_descr = self.assembler.cpu.gc_ll_descr
self.rm.force_allocate_reg(op.result, selected_reg=eax)
#
@@ -987,6 +993,7 @@
)
def consider_new(self, op):
+ KILLME
gc_ll_descr = self.assembler.cpu.gc_ll_descr
if gc_ll_descr.can_inline_malloc(op.getdescr()):
self.fastpath_malloc_fixedsize(op, op.getdescr())
@@ -996,6 +1003,7 @@
return self._call(op, arglocs)
def consider_new_with_vtable(self, op):
+ KILLME
classint = op.getarg(0).getint()
descrsize = heaptracker.vtable2descr(self.assembler.cpu, classint)
if self.assembler.cpu.gc_ll_descr.can_inline_malloc(descrsize):
@@ -1009,14 +1017,17 @@
return self._call(op, arglocs)
def consider_newstr(self, op):
+ KILLME
loc = self.loc(op.getarg(0))
return self._call(op, [loc])
def consider_newunicode(self, op):
+ KILLME
loc = self.loc(op.getarg(0))
return self._call(op, [loc])
def consider_new_array(self, op):
+ KILLME
gc_ll_descr = self.assembler.cpu.gc_ll_descr
box_num_elem = op.getarg(0)
if isinstance(box_num_elem, ConstInt):
@@ -1032,34 +1043,32 @@
self._call(op, arglocs)
def _unpack_arraydescr(self, arraydescr):
- assert isinstance(arraydescr, BaseArrayDescr)
- ofs_length = arraydescr.get_ofs_length(self.translate_support_code)
- ofs = arraydescr.get_base_size(self.translate_support_code)
- size = arraydescr.get_item_size(self.translate_support_code)
- ptr = arraydescr.is_array_of_pointers()
+ assert isinstance(arraydescr, ArrayDescr)
+ ofs = arraydescr.basesize
+ size = arraydescr.itemsize
sign = arraydescr.is_item_signed()
- return size, ofs, ofs_length, ptr, sign
+ return size, ofs, sign
def _unpack_fielddescr(self, fielddescr):
- assert isinstance(fielddescr, BaseFieldDescr)
+ assert isinstance(fielddescr, FieldDescr)
ofs = fielddescr.offset
- size = fielddescr.get_field_size(self.translate_support_code)
- ptr = fielddescr.is_pointer_field()
+ size = fielddescr.field_size
sign = fielddescr.is_field_signed()
- return imm(ofs), imm(size), ptr, sign
+ return imm(ofs), imm(size), sign
+ _unpack_fielddescr._always_inline_ = True
def _unpack_interiorfielddescr(self, descr):
assert isinstance(descr, InteriorFieldDescr)
arraydescr = descr.arraydescr
- ofs = arraydescr.get_base_size(self.translate_support_code)
- itemsize = arraydescr.get_item_size(self.translate_support_code)
- fieldsize =
descr.fielddescr.get_field_size(self.translate_support_code)
+ ofs = arraydescr.basesize
+ itemsize = arraydescr.itemsize
+ fieldsize = descr.fielddescr.field_size
sign = descr.fielddescr.is_field_signed()
ofs += descr.fielddescr.offset
return imm(ofs), imm(itemsize), imm(fieldsize), sign
def consider_setfield_gc(self, op):
- ofs_loc, size_loc, _, _ = self._unpack_fielddescr(op.getdescr())
+ ofs_loc, size_loc, _ = self._unpack_fielddescr(op.getdescr())
assert isinstance(size_loc, ImmedLoc)
if size_loc.value == 1:
need_lower_byte = True
@@ -1117,7 +1126,7 @@
consider_unicodesetitem = consider_strsetitem
def consider_setarrayitem_gc(self, op):
- itemsize, ofs, _, _, _ = self._unpack_arraydescr(op.getdescr())
+ itemsize, ofs, _ = self._unpack_arraydescr(op.getdescr())
args = op.getarglist()
base_loc = self.rm.make_sure_var_in_reg(op.getarg(0), args)
if itemsize == 1:
@@ -1134,7 +1143,7 @@
consider_setarrayitem_raw = consider_setarrayitem_gc
def consider_getfield_gc(self, op):
- ofs_loc, size_loc, _, sign = self._unpack_fielddescr(op.getdescr())
+ ofs_loc, size_loc, sign = self._unpack_fielddescr(op.getdescr())
args = op.getarglist()
base_loc = self.rm.make_sure_var_in_reg(op.getarg(0), args)
self.rm.possibly_free_vars(args)
@@ -1150,7 +1159,7 @@
consider_getfield_gc_pure = consider_getfield_gc
def consider_getarrayitem_gc(self, op):
- itemsize, ofs, _, _, sign = self._unpack_arraydescr(op.getdescr())
+ itemsize, ofs, sign = self._unpack_arraydescr(op.getdescr())
args = op.getarglist()
base_loc = self.rm.make_sure_var_in_reg(op.getarg(0), args)
ofs_loc = self.rm.make_sure_var_in_reg(op.getarg(1), args)
@@ -1229,8 +1238,8 @@
def consider_arraylen_gc(self, op):
arraydescr = op.getdescr()
- assert isinstance(arraydescr, BaseArrayDescr)
- ofs = arraydescr.get_ofs_length(self.translate_support_code)
+ assert isinstance(arraydescr, ArrayDescr)
+ ofs = arraydescr.lendescr.offset
args = op.getarglist()
base_loc = self.rm.make_sure_var_in_reg(op.getarg(0), args)
self.rm.possibly_free_vars_for_op(op)
diff --git a/pypy/jit/metainterp/executor.py b/pypy/jit/metainterp/executor.py
--- a/pypy/jit/metainterp/executor.py
+++ b/pypy/jit/metainterp/executor.py
@@ -46,7 +46,7 @@
# get the function address as an integer
func = argboxes[0].getint()
# do the call using the correct function from the cpu
- rettype = descr.get_return_type()
+ rettype = descr.get_result_type()
if rettype == INT or rettype == 'S': # *S*ingle float
try:
result = cpu.bh_call_i(func, descr, args_i, args_r, args_f)
_______________________________________________
pypy-commit mailing list
[email protected]
http://mail.python.org/mailman/listinfo/pypy-commit
