[pypy-svn] r65669 - pypy/branch/pyjitpl5-experiments/pypy/jit/backend/llvm

arigo at codespeak.net arigo at codespeak.net
Mon Jun 8 19:31:51 CEST 2009


Author: arigo
Date: Mon Jun  8 19:31:49 2009
New Revision: 65669

Modified:
   pypy/branch/pyjitpl5-experiments/pypy/jit/backend/llvm/compile.py
   pypy/branch/pyjitpl5-experiments/pypy/jit/backend/llvm/runner.py
Log:
More code cleanups.


Modified: pypy/branch/pyjitpl5-experiments/pypy/jit/backend/llvm/compile.py
==============================================================================
--- pypy/branch/pyjitpl5-experiments/pypy/jit/backend/llvm/compile.py	(original)
+++ pypy/branch/pyjitpl5-experiments/pypy/jit/backend/llvm/compile.py	Mon Jun  8 19:31:49 2009
@@ -395,8 +395,7 @@
         self._generate_guard(op, equal, False)
 
     def generate_GUARD_CLASS(self, op):
-        loc, _ = self._generate_field_gep(op.args[0],
-                                          self.cpu.fielddescr_vtable)
+        loc = self._generate_field_gep(op.args[0], self.cpu.fielddescr_vtable)
         cls = llvm_rffi.LLVMBuildLoad(self.builder, loc, "")
         equal = llvm_rffi.LLVMBuildICmp(self.builder,
                                         llvm_rffi.Predicate.EQ,
@@ -492,13 +491,12 @@
                                           self.getptrarg(v_structure),
                                           indices, 1, "")
         lltype.free(indices, flavor='raw')
-        ty_val = self.cpu.types_by_index[fielddescr.size_index]
         ty = self.cpu.types_ptr_by_index[fielddescr.size_index]
         location = llvm_rffi.LLVMBuildBitCast(self.builder, location, ty, "")
-        return location, ty_val
+        return location
 
     def generate_GETFIELD_GC(self, op):
-        loc, _ = self._generate_field_gep(op.args[0], op.descr)
+        loc = self._generate_field_gep(op.args[0], op.descr)
         self.vars[op.result] = llvm_rffi.LLVMBuildLoad(self.builder, loc, "")
 
     generate_GETFIELD_GC_PURE  = generate_GETFIELD_GC
@@ -506,13 +504,11 @@
     generate_GETFIELD_RAW_PURE = generate_GETFIELD_GC
 
     def generate_SETFIELD_GC(self, op):
-        loc, tyval = self._generate_field_gep(op.args[0], op.descr)
-        if tyval == self.cpu.ty_char_ptr:
-            value_ref = self.getptrarg(op.args[1])
-        elif tyval == self.cpu.ty_char:
-            value_ref = self.getchararg(op.args[1])
-        else:
-            value_ref = self.getintarg(op.args[1])
+        fielddescr = op.descr
+        loc = self._generate_field_gep(op.args[0], fielddescr)
+        assert isinstance(fielddescr, FieldDescr)
+        getarg = self.cpu.getarg_by_index[fielddescr.size_index]
+        value_ref = getarg(self, op.args[1])
         llvm_rffi.LLVMBuildStore(self.builder, value_ref, loc, "")
 
     def generate_CALL(self, op):
@@ -584,99 +580,84 @@
             self.getptrarg(op.args[0]),
             self.cpu.const_null_charptr, "")
 
-    def generate_ARRAYLEN_GC(self, op):
-        arraydescr = op.descr
-        assert isinstance(arraydescr, ArrayDescr)
+    def _generate_len(self, op, ty, const_index_length):
         array = llvm_rffi.LLVMBuildBitCast(self.builder,
                                            self.getptrarg(op.args[0]),
-                                           arraydescr.ty_array_ptr, "")
+                                           ty, "")
         indices = lltype.malloc(rffi.CArray(llvm_rffi.LLVMValueRef), 2,
                                 flavor='raw')
         indices[0] = self.cpu.const_zero
-        indices[1] = self.cpu.const_array_index_length
+        indices[1] = const_index_length
         loc = llvm_rffi.LLVMBuildGEP(self.builder, array, indices, 2, "")
         lltype.free(indices, flavor='raw')
         self.vars[op.result] = llvm_rffi.LLVMBuildLoad(self.builder, loc, "")
 
-    def _generate_gep(self, v_array, v_index, ty, const_index_array):
+    def generate_ARRAYLEN_GC(self, op):
+        arraydescr = op.descr
+        assert isinstance(arraydescr, ArrayDescr)
+        self._generate_len(op, arraydescr.ty_array_ptr,
+                           self.cpu.const_array_index_length)
+
+    def _generate_gep(self, op, ty, const_index_array):
         array = llvm_rffi.LLVMBuildBitCast(self.builder,
-                                           self.getptrarg(v_array),
+                                           self.getptrarg(op.args[0]),
                                            ty, "")
         indices = lltype.malloc(rffi.CArray(llvm_rffi.LLVMValueRef), 3,
                                 flavor='raw')
         indices[0] = self.cpu.const_zero
         indices[1] = const_index_array
-        indices[2] = self.getintarg(v_index)
+        indices[2] = self.getintarg(op.args[1])
         location = llvm_rffi.LLVMBuildGEP(self.builder, array, indices, 3, "")
         lltype.free(indices, flavor='raw')
         return location
 
-    def _generate_array_gep(self, v_array, v_index, arraydescr):
+    def _generate_array_gep(self, op):
+        arraydescr = op.descr
         assert isinstance(arraydescr, ArrayDescr)
-        location = self._generate_gep(v_array, v_index,
-                                      arraydescr.ty_array_ptr,
+        location = self._generate_gep(op, arraydescr.ty_array_ptr,
                                       self.cpu.const_array_index_array)
-        ty_val = self.cpu.types_by_index[arraydescr.itemsize_index]
-        return location, ty_val
+        return location
 
     def generate_GETARRAYITEM_GC(self, op):
-        loc, _ = self._generate_array_gep(op.args[0], op.args[1], op.descr)
+        loc = self._generate_array_gep(op)
         self.vars[op.result] = llvm_rffi.LLVMBuildLoad(self.builder, loc, "")
 
     generate_GETARRAYITEM_GC_PURE = generate_GETARRAYITEM_GC
 
     def generate_SETARRAYITEM_GC(self, op):
-        loc, tyval = self._generate_array_gep(op.args[0], op.args[1], op.descr)
-        if tyval == self.cpu.ty_char_ptr:
-            value_ref = self.getptrarg(op.args[2])
-        elif tyval == self.cpu.ty_char:
-            value_ref = self.getchararg(op.args[2])
-        else:
-            value_ref = self.getintarg(op.args[2])
+        loc = self._generate_array_gep(op)
+        arraydescr = op.descr
+        assert isinstance(arraydescr, ArrayDescr)
+        getarg = self.cpu.getarg_by_index[arraydescr.itemsize_index]
+        value_ref = getarg(self, op.args[2])
         llvm_rffi.LLVMBuildStore(self.builder, value_ref, loc, "")
 
-    def _generate_str_unicode_len(self, op, ty, const_index_length):
-        array = llvm_rffi.LLVMBuildBitCast(self.builder,
-                                           self.getptrarg(op.args[0]),
-                                           ty, "")
-        indices = lltype.malloc(rffi.CArray(llvm_rffi.LLVMValueRef), 2,
-                                flavor='raw')
-        indices[0] = self.cpu.const_zero
-        indices[1] = const_index_length
-        loc = llvm_rffi.LLVMBuildGEP(self.builder, array, indices, 2, "")
-        lltype.free(indices, flavor='raw')
-        self.vars[op.result] = llvm_rffi.LLVMBuildLoad(self.builder, loc, "")
-
     def generate_STRLEN(self, op):
-        self._generate_str_unicode_len(op, self.cpu.ty_string_ptr,
-                                       self.cpu.const_string_index_length)
+        self._generate_len(op, self.cpu.ty_string_ptr,
+                           self.cpu.const_string_index_length)
 
     def generate_UNICODELEN(self, op):
-        self._generate_str_unicode_len(op, self.cpu.ty_unicode_ptr,
-                                       self.cpu.const_unicode_index_length)
+        self._generate_len(op, self.cpu.ty_unicode_ptr,
+                           self.cpu.const_unicode_index_length)
 
     def generate_STRGETITEM(self, op):
-        loc = self._generate_gep(op.args[0], op.args[1],
-                                 self.cpu.ty_string_ptr,
+        loc = self._generate_gep(op, self.cpu.ty_string_ptr,
                                  self.cpu.const_string_index_array)
         self.vars[op.result] = llvm_rffi.LLVMBuildLoad(self.builder, loc, "")
 
     def generate_UNICODEGETITEM(self, op):
-        loc = self._generate_gep(op.args[0], op.args[1],
-                                 self.cpu.ty_unicode_ptr,
+        loc = self._generate_gep(op, self.cpu.ty_unicode_ptr,
                                  self.cpu.const_unicode_index_array)
         self.vars[op.result] = llvm_rffi.LLVMBuildLoad(self.builder, loc, "")
 
     def generate_STRSETITEM(self, op):
-        loc = self._generate_gep(op.args[0], op.args[1],
-                                 self.cpu.ty_string_ptr,
+        loc = self._generate_gep(op, self.cpu.ty_string_ptr,
                                  self.cpu.const_string_index_array)
         value_ref = self.getchararg(op.args[2])
         llvm_rffi.LLVMBuildStore(self.builder, value_ref, loc, "")
 
     def generate_UNICODESETITEM(self, op):
-        loc = self._generate_gep(op.args[0], op.args[1],
-                                 self.cpu.ty_unicode_ptr,
+        loc = self._generate_gep(op, self.cpu.ty_unicode_ptr,
                                  self.cpu.const_unicode_index_array)
         value_ref = self.getunichararg(op.args[2])
         llvm_rffi.LLVMBuildStore(self.builder, value_ref, loc, "")

Modified: pypy/branch/pyjitpl5-experiments/pypy/jit/backend/llvm/runner.py
==============================================================================
--- pypy/branch/pyjitpl5-experiments/pypy/jit/backend/llvm/runner.py	(original)
+++ pypy/branch/pyjitpl5-experiments/pypy/jit/backend/llvm/runner.py	Mon Jun  8 19:31:49 2009
@@ -19,9 +19,10 @@
     SIGNED_VALUE = rffi.CFixedArray(lltype.Signed, 1)
     POINTER_VALUE = rffi.CFixedArray(llmemory.GCREF, 1)
 
-    SIZE_GCPTR = 0
-    SIZE_INT   = 1
-    SIZE_CHAR  = 2
+    SIZE_GCPTR   = 0
+    SIZE_INT     = 1
+    SIZE_CHAR    = 2
+    SIZE_UNICHAR = 3
 
     def __init__(self, rtyper, stats=None, translate_support_code=False,
                  annmixlevel=None):
@@ -31,9 +32,10 @@
         self.fail_ops = []
         self.in_out_args = []
         self._descr_caches = {
-            ('array', self.SIZE_GCPTR): ArrayDescr(self.SIZE_GCPTR),
-            ('array', self.SIZE_INT):   ArrayDescr(self.SIZE_INT),
-            ('array', self.SIZE_CHAR):  ArrayDescr(self.SIZE_CHAR),
+            ('array', self.SIZE_GCPTR):   ArrayDescr(self.SIZE_GCPTR),
+            ('array', self.SIZE_INT):     ArrayDescr(self.SIZE_INT),
+            ('array', self.SIZE_CHAR):    ArrayDescr(self.SIZE_CHAR),
+            ('array', self.SIZE_UNICHAR): ArrayDescr(self.SIZE_UNICHAR),
             }
         self.fielddescr_vtable = self.fielddescrof(rclass.OBJECT, 'typeptr')
         if sys.maxint == 2147483647:
@@ -74,17 +76,25 @@
         self.ty_char_ptr_ptr = llvm_rffi.LLVMPointerType(self.ty_char_ptr, 0)
         self.ty_int_ptr = llvm_rffi.LLVMPointerType(self.ty_int, 0)
         self.ty_int_ptr_ptr = llvm_rffi.LLVMPointerType(self.ty_int_ptr, 0)
+        self.ty_unichar_ptr = llvm_rffi.LLVMPointerType(self.ty_unichar, 0)
         self.const_zero = self._make_const_int(0)
         self.const_one  = self._make_const_int(1)
         self.const_minint = self._make_const_int(-sys.maxint-1)
         self.const_null_charptr = self._make_const(0, self.ty_char_ptr)
         #
+        from pypy.jit.backend.llvm.compile import LLVMJITCompiler
         self.types_by_index = [self.ty_char_ptr,     # SIZE_GCPTR
                                self.ty_int,          # SIZE_INT
-                               self.ty_char]         # SIZE_CHAR
+                               self.ty_char,         # SIZE_CHAR
+                               self.ty_unichar]      # SIZE_UNICHAR
         self.types_ptr_by_index = [self.ty_char_ptr_ptr,   # SIZE_GCPTR
                                    self.ty_int_ptr,        # SIZE_INT
-                                   self.ty_char_ptr]       # SIZE_CHAR
+                                   self.ty_char_ptr,       # SIZE_CHAR
+                                   self.ty_unichar_ptr]    # SIZE_UNICHAR
+        self.getarg_by_index = [LLVMJITCompiler.getptrarg,     # SIZE_GCPTR
+                                LLVMJITCompiler.getintarg,     # SIZE_INT
+                                LLVMJITCompiler.getchararg,    # SIZE_CHAR
+                                LLVMJITCompiler.getunichararg] # SIZE_UNICHAR
         (shape_basesize, shape_length) = self._fixed_array_shape
         for i in range(len(self.types_by_index)):
             arraydescr = self._descr_caches['array', i]
@@ -327,6 +337,9 @@
                 return self.SIZE_INT
             elif size == 1:
                 return self.SIZE_CHAR
+            elif size == symbolic.get_size(lltype.UniChar,
+                                           self.translate_support_code):
+                return self.SIZE_UNICHAR
             else:
                 raise BadSizeError(S, fieldname, size)
 



More information about the Pypy-commit mailing list