[pypy-commit] pypy ppc-jit-backend: Implemented NEW_ARRAY

[hager]

Author: hager <sven.hager at uni-duesseldorf.de>
Branch: ppc-jit-backend
Changeset: r49441:b2ad6b915f48
Date: 2011-11-15 19:02 +0100
http://bitbucket.org/pypy/pypy/changeset/b2ad6b915f48/

Log:	Implemented NEW_ARRAY

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
@@ -12,7 +12,7 @@
 from pypy.jit.backend.ppc.ppcgen.jump import remap_frame_layout
 from pypy.jit.backend.ppc.ppcgen.regalloc import TempPtr
 from pypy.jit.backend.llsupport import symbolic
-from pypy.rpython.lltypesystem import rstr
+from pypy.rpython.lltypesystem import rstr, rffi, lltype
 
 NO_FORCE_INDEX = -1
 
@@ -610,6 +610,15 @@
         # XXX do exception handling here!
         pass
 
+    def emit_new_array(self, op, arglocs, regalloc):
+        # XXX handle memory errors
+        if len(arglocs) > 0:
+            value_loc, base_loc, ofs_length = arglocs
+            if IS_PPC_32:
+                self.mc.stw(value_loc.value, base_loc.value, ofs_length.value)
+            else:
+                self.mc.std(value_loc.value, base_loc.value, ofs_length.value)
+
     def emit_same_as(self, op, arglocs, regalloc):
         argloc, resloc = arglocs
         self.regalloc_mov(argloc, resloc)
@@ -771,3 +780,20 @@
 
     def nop(self):
         self.mc.ori(0, 0, 0)
+
+    # from: ../x86/regalloc.py:750
+    # called from regalloc
+    # XXX kill this function at some point
+    def _regalloc_malloc_varsize(self, size, size_box, vloc, vbox, ofs_items_loc, regalloc, result):
+        if IS_PPC_32:
+            self.mc.mullw(size.value, size.value, vloc.value)
+        else:
+            self.mc.mulld(size.value, size.value, vloc.value)
+        if ofs_items_loc.is_imm():
+            self.mc.addi(size.value, size.value, ofs_items_loc.value)
+        else:
+            self.mc.add(size.value, size.value, ofs_items_loc.value)
+        force_index = self.write_new_force_index()
+        regalloc.force_spill_var(vbox)
+        self._emit_call(force_index, self.malloc_func_addr, [size_box], regalloc,
+                                    result=result)
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
@@ -116,6 +116,7 @@
         self.fail_boxes_ptr = values_array(llmemory.GCREF, failargs_limit)
         self.mc = None
         self.malloc_func_addr = 0
+        self.malloc_array_func_addr = 0
         self.datablockwrapper = None
         self.memcpy_addr = 0
         self.fail_boxes_count = 0
@@ -462,6 +463,10 @@
         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)
         self.memcpy_addr = self.cpu.cast_ptr_to_int(memcpy_fn)
         self.setup_failure_recovery()
         self.exit_code_adr = self._gen_exit_path()
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
@@ -20,6 +20,7 @@
 from pypy.jit.backend.llsupport import symbolic
 from pypy.jit.codewriter.effectinfo import EffectInfo
 import pypy.jit.backend.ppc.ppcgen.register as r
+from pypy.jit.codewriter import heaptracker
 
 class TempInt(TempBox):
     type = INT
@@ -638,6 +639,27 @@
         self.possibly_free_var(op.result)
         return []
 
+    def prepare_new_array(self, op):
+        gc_ll_descr = self.cpu.gc_ll_descr
+        if gc_ll_descr.get_funcptr_for_newarray is not None:
+            # framework GC
+            box_num_elem = op.getarg(0)
+            if isinstance(box_num_elem, ConstInt):
+                num_elem = box_num_elem.value
+                # XXX implement fastpath for malloc
+            args = self.assembler.cpu.gc_ll_descr.args_for_new_array(
+                op.getdescr())
+            argboxes = [ConstInt(x) for x in args]
+            argboxes.append(box_num_elem)
+            force_index = self.assembler.write_new_force_index()
+            self.assembler._emit_call(force_index, self.assembler.malloc_array_func_addr,
+                                        argboxes, self, result=op.result)
+            return []
+        # boehm GC
+        itemsize, scale, basesize, ofs_length, _ = (
+            self._unpack_arraydescr(op.getdescr()))
+        return self._malloc_varsize(basesize, ofs_length, itemsize, op)
+
     def prepare_call(self, op):
         effectinfo = op.getdescr().get_extra_info()
         if effectinfo is not None:
@@ -664,6 +686,32 @@
             arglocs.append(t)
         return arglocs
 
+    def _malloc_varsize(self, ofs_items, ofs_length, itemsize, op):
+        v = op.getarg(0)
+        res_v = op.result
+        boxes = [v, res_v]
+        itemsize_box = ConstInt(itemsize)
+        ofs_items_box = ConstInt(ofs_items)
+        if _check_imm_arg(ofs_items_box):
+            ofs_items_loc = self.convert_to_imm(ofs_items_box)
+        else:
+            ofs_items_loc, ofs_items_box = self._ensure_value_is_boxed(ofs_items_box, boxes)
+            boxes.append(ofs_items_box)
+        vloc, vbox = self._ensure_value_is_boxed(v, [res_v])
+        boxes.append(vbox)
+        size, size_box = self._ensure_value_is_boxed(itemsize_box, boxes)
+        boxes.append(size_box)
+        self.assembler._regalloc_malloc_varsize(size, size_box,
+                                vloc, vbox, ofs_items_loc, self, res_v)
+        base_loc = self.make_sure_var_in_reg(res_v)
+
+        value_loc, vbox = self._ensure_value_is_boxed(v, [res_v])
+        boxes.append(vbox)
+        self.possibly_free_vars(boxes)
+        assert value_loc.is_reg()
+        assert base_loc.is_reg()
+        return [value_loc, base_loc, imm(ofs_length)]
+
     # from ../x86/regalloc.py:791
     def _unpack_fielddescr(self, fielddescr):
         assert isinstance(fielddescr, BaseFieldDescr)