value_to_ir_value new optional argument type_

Author: jdavid

py2llvm/py2llvm.py

@@ -17,7 +17,7 @@
 
 class Range:
 
-    def __init__(self, *args):
+    def __init__(self, builder, *args):
         start = step = None
 
         # Unpack
@@ -37,9 +37,9 @@ def __init__(self, *args):
             step = ir.Constant(type_, 1)
 
         # Keep IR values
-        self.start = types.value_to_ir_value(start)
-        self.stop = types.value_to_ir_value(stop)
-        self.step = types.value_to_ir_value(step)
+        self.start = types.value_to_ir_value(builder, start)
+        self.stop = types.value_to_ir_value(builder, stop)
+        self.step = types.value_to_ir_value(builder, step)
 
 
 def values_to_type(left, right):
@@ -504,39 +504,7 @@ def convert(self, value, type_):
         """
         Return the value converted to the given type.
         """
-        # If Python value, return a constant
-        if not isinstance(value, ir.Value):
-            return ir.Constant(type_, value)
-
-        if value.type is type_:
-            return value
-
-        conversions = {
-            # Integer to float
-            (ir.IntType, ir.FloatType): self.builder.sitofp,
-            (ir.IntType, ir.DoubleType): self.builder.sitofp,
-            # Float to integer
-            (ir.FloatType, ir.IntType): self.builder.fptosi,
-            (ir.DoubleType, ir.IntType): self.builder.fptosi,
-            # Float to float
-            (ir.FloatType, ir.DoubleType): self.builder.fpext,
-            (ir.DoubleType, ir.FloatType): self.builder.fptrunc,
-        }
-
-        if isinstance(value.type, ir.IntType) and isinstance(type_, ir.IntType):
-            # Integer to integer
-            if value.type.width < type_.width:
-                conversion = self.builder.zext
-            else:
-                conversion = self.builder.trunc
-        else:
-            # To or from float
-            conversion = conversions.get((type(value.type), type(type_)))
-            if conversion is None:
-                err = f'Conversion from {value.type} to {type_} not supported'
-                raise NotImplementedError(err)
-
-        return conversion(value, type_)
+        return types.value_to_ir_value(self.builder, value, type_)
 
     #
     # Leaf nodes
@@ -925,7 +893,8 @@ def Assign_exit(self, node, parent, targets, value, *args):
         if len(targets) > 1:
             raise NotImplementedError(f'unpacking not supported')
 
-        value = types.value_to_ir_value(value, visitor=self)
+        builder = self.builder
+        value = types.value_to_ir_value(builder, value)
 
         target = targets[0]
         if type(target) is str:
@@ -934,16 +903,16 @@ def Assign_exit(self, node, parent, targets, value, *args):
             try:
                 ptr = self.lookup(name)
             except AttributeError:
-                block_cur = self.builder.block
-                self.builder.position_at_end(self.block_vars)
-                ptr = self.builder.alloca(value.type, name=name)
-                self.builder.position_at_end(block_cur)
+                block_cur = builder.block
+                builder.position_at_end(self.block_vars)
+                ptr = builder.alloca(value.type, name=name)
+                builder.position_at_end(block_cur)
                 self.locals[name] = ptr
         else:
             # x[i] =
             ptr = target
 
-        return self.builder.store(value, ptr)
+        return builder.store(value, ptr)
 
     def AugAssign_exit(self, node, parent, target, op, value):
         """
@@ -975,7 +944,7 @@ def Call_exit(self, node, parent, func, args, keywords):
         """
         assert not keywords
         if func is range:
-            return Range(*args)
+            return Range(self.builder, *args)
 
         func = self.root.compiled.get(func, func)
         return self.builder.call(func, args)

py2llvm/types.py

@@ -80,25 +80,48 @@ def value_to_ir_type(value):
     return type_to_ir_type(type_)
 
 
-def value_to_ir_value(value, visitor=None):
+def value_to_ir_value(builder, value, type_=None):
     """
-    Return a IR value for the given value, where value may be:
-    - an IR value, then we're done, return it
-    - a special object that knows to return a IR value (duck typing)
-    - a regular Python value, then return a IR constant
+    Return a IR value for the given value, where value may be either a Python
+    or an IR value. If type_ is given the value will be converted to the given
+    type (if necessary).
     """
-    if isinstance(value, ir.Value):
+    if type_ is None:
+        type_ = value_to_ir_type(value)
+
+    # If Python value, return a constant
+    if not isinstance(value, ir.Value):
+        return ir.Constant(type_, value)
+
+    if value.type is type_:
         return value
 
-    # Special object
-    to_ir_value = getattr(value, 'to_ir_value', None)
-    if to_ir_value is not None:
-        assert visitor is not None
-        return to_ir_value(visitor)
+    conversions = {
+        # Integer to float
+        (ir.IntType, ir.FloatType): builder.sitofp,
+        (ir.IntType, ir.DoubleType): builder.sitofp,
+        # Float to integer
+        (ir.FloatType, ir.IntType): builder.fptosi,
+        (ir.DoubleType, ir.IntType): builder.fptosi,
+        # Float to float
+        (ir.FloatType, ir.DoubleType): builder.fpext,
+        (ir.DoubleType, ir.FloatType): builder.fptrunc,
+    }
+
+    if isinstance(value.type, ir.IntType) and isinstance(type_, ir.IntType):
+        # Integer to integer
+        if value.type.width < type_.width:
+            conversion = builder.zext
+        else:
+            conversion = builder.trunc
+    else:
+        # To or from float
+        conversion = conversions.get((type(value.type), type(type_)))
+        if conversion is None:
+            err = f'Conversion from {value.type} to {type_} not supported'
+            raise NotImplementedError(err)
 
-    # Regular Python object
-    ir_type = value_to_ir_type(value)
-    return ir.Constant(ir_type, value)
+    return conversion(value, type_)
 
 
 #
@@ -143,6 +166,8 @@ def get_ptr(self, visitor):
         return visitor.builder.load(self.ptr)
 
     def subscript(self, visitor, slice, ctx):
+        builder = visitor.builder
+
         # To make it simpler, make the slice to be a list always
         if type(slice) is not list:
             slice = [slice]
@@ -152,7 +177,7 @@ def subscript(self, visitor, slice, ctx):
 
         assert ptr.type.is_pointer
         if isinstance(ptr.type.pointee, ir.ArrayType):
-            ptr = visitor.builder.gep(ptr, [zero])
+            ptr = builder.gep(ptr, [zero])
 
         # Support for multidimensional arrays.
         # Let's we have 3 dimensions (d0, d1, d2), each with a length (dl0,
@@ -163,17 +188,17 @@ def subscript(self, visitor, slice, ctx):
         dim = 1
         while slice:
             idx = slice.pop(0)
-            idx = value_to_ir_value(idx)
+            idx = value_to_ir_value(builder, idx)
             for i in range(dim, self.ndim):
                 dim_len = self.shape.get(visitor, dim)
-                idx = visitor.builder.mul(idx, dim_len)
+                idx = builder.mul(idx, dim_len)
 
-            ptr = visitor.builder.gep(ptr, [idx])
+            ptr = builder.gep(ptr, [idx])
             dim += 1
 
         # Return the value
         if ctx is ast.Load:
-            return visitor.builder.load(ptr)
+            return builder.load(ptr)
         elif ctx is ast.Store:
             return ptr
 

try_ia.py

@@ -72,9 +72,10 @@ def __init__(self, ptr, typs):
         self.typs = typs
 
     def subscript(self, visitor, slice, ctx):
+        builder = visitor.builder
         typ = self.typs[slice]
-        idx = types.value_to_ir_value(slice)
-        ptr = visitor.builder.gep(self.ptr, [types.zero, idx])
+        idx = types.value_to_ir_value(builder, slice)
+        ptr = builder.gep(self.ptr, [types.zero, idx])
         return params_type_input(ptr, typ)
 
 class params_type_out: