llvmlite 0.43.0rc1__cp312-cp312-macosx_11_0_arm64.whl → 0.44.0rc2__cp312-cp312-macosx_11_0_arm64.whl

llvmlite/binding/typeref.py

@@ -1,8 +1,12 @@
-from ctypes import c_int, c_bool, c_void_p, c_uint64
+from ctypes import c_int, c_bool, c_void_p, c_uint64, c_uint, POINTER
 import enum
 
+from llvmlite import ir
 from llvmlite.binding import ffi
 
+# FIXME: Remove `opaque_pointers_enabled' when TP's are removed.
+from llvmlite import opaque_pointers_enabled
+
 
 class TypeKind(enum.IntEnum):
     # The LLVMTypeKind enum from llvm-c/Core.h
@@ -29,6 +33,21 @@ class TypeKind(enum.IntEnum):
     x86_amx = 19
 
 
+_TypeKindToIRType = {
+    # All TypeKind here must have a TypeRef.as_ir() implementation
+    TypeKind.void: ir.VoidType,
+    TypeKind.half: ir.HalfType,
+    TypeKind.float: ir.FloatType,
+    TypeKind.double: ir.DoubleType,
+    TypeKind.integer: ir.IntType,
+    TypeKind.function: ir.FunctionType,
+    TypeKind.pointer: ir.PointerType,
+    TypeKind.array: ir.ArrayType,
+    TypeKind.vector: ir.VectorType,
+    TypeKind.struct: ir.LiteralStructType,
+}
+
+
 class TypeRef(ffi.ObjectRef):
     """A weak reference to a LLVM type
     """
@@ -67,6 +86,13 @@ class TypeRef(ffi.ObjectRef):
         """
         return ffi.lib.LLVMPY_TypeIsVector(self)
 
+    @property
+    def is_function(self):
+        """
+        Returns true if the type is a function type.
+        """
+        return ffi.lib.LLVMPY_TypeIsFunction(self)
+
     @property
     def is_function_vararg(self):
         """
@@ -82,8 +108,11 @@ class TypeRef(ffi.ObjectRef):
         """
         Returns iterator over enclosing types
         """
+        if self.is_pointer and opaque_pointers_enabled:
+            raise ValueError("Type {} doesn't contain elements.".format(self))
         return _TypeListIterator(ffi.lib.LLVMPY_ElementIter(self))
 
+    # FIXME: Remove me once typed pointers support is removed.
     @property
     def element_type(self):
         """
@@ -129,6 +158,41 @@ class TypeRef(ffi.ObjectRef):
         """
         return TypeKind(ffi.lib.LLVMPY_GetTypeKind(self))
 
+    @property
+    def is_packed_struct(self):
+        return ffi.lib.LLVMPY_IsPackedStruct(self)
+
+    @property
+    def is_literal_struct(self):
+        return ffi.lib.LLVMPY_IsLiteralStruct(self)
+
+    @property
+    def is_opaque_struct(self):
+        return ffi.lib.LLVMPY_IsOpaqueStruct(self)
+
+    def get_function_parameters(self) -> tuple["TypeRef"]:
+        nparams = ffi.lib.LLVMPY_CountParamTypes(self)
+        if nparams > 0:
+            out_buffer = (ffi.LLVMTypeRef * nparams)(None)
+            ffi.lib.LLVMPY_GetParamTypes(self, out_buffer)
+            return tuple(map(TypeRef, out_buffer))
+        else:
+            return ()
+
+    def get_function_return(self) -> "TypeRef":
+        return TypeRef(ffi.lib.LLVMPY_GetReturnType(self))
+
+    def as_ir(self, ir_ctx: ir.Context) -> ir.Type:
+        """Convert into a ``llvmlite.ir.Type``.
+        """
+        try:
+            cls = _TypeKindToIRType[self.type_kind]
+        except KeyError:
+            msg = f"as_ir() unsupported for TypeRef of {self.type_kind}"
+            raise TypeError(msg)
+        else:
+            return cls.from_llvm(self, ir_ctx)
+
     def __str__(self):
         return ffi.ret_string(ffi.lib.LLVMPY_PrintType(self))
 
@@ -162,6 +226,7 @@ class _TypeListIterator(_TypeIterator):
 ffi.lib.LLVMPY_PrintType.argtypes = [ffi.LLVMTypeRef]
 ffi.lib.LLVMPY_PrintType.restype = c_void_p
 
+# FIXME: Remove me once typed pointers support is removed.
 ffi.lib.LLVMPY_GetElementType.argtypes = [ffi.LLVMTypeRef]
 ffi.lib.LLVMPY_GetElementType.restype = ffi.LLVMTypeRef
 
@@ -177,6 +242,28 @@ ffi.lib.LLVMPY_TypeIsVector.restype = c_bool
 ffi.lib.LLVMPY_TypeIsStruct.argtypes = [ffi.LLVMTypeRef]
 ffi.lib.LLVMPY_TypeIsStruct.restype = c_bool
 
+ffi.lib.LLVMPY_TypeIsFunction.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_TypeIsFunction.restype = c_bool
+
+ffi.lib.LLVMPY_IsPackedStruct.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_IsPackedStruct.restype = c_bool
+
+ffi.lib.LLVMPY_IsOpaqueStruct.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_IsOpaqueStruct.restype = c_bool
+
+ffi.lib.LLVMPY_IsLiteralStruct.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_IsLiteralStruct.restype = c_bool
+
+ffi.lib.LLVMPY_GetReturnType.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_GetReturnType.restype = ffi.LLVMTypeRef
+
+ffi.lib.LLVMPY_CountParamTypes.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_CountParamTypes.restype = c_uint
+
+ffi.lib.LLVMPY_GetParamTypes.argtypes = [ffi.LLVMTypeRef,
+                                         POINTER(ffi.LLVMTypeRef)]
+ffi.lib.LLVMPY_GetParamTypes.restype = None
+
 ffi.lib.LLVMPY_IsFunctionVararg.argtypes = [ffi.LLVMTypeRef]
 ffi.lib.LLVMPY_IsFunctionVararg.restype = c_bool
 

llvmlite/binding/value.py

@@ -217,6 +217,17 @@ class ValueRef(ffi.ObjectRef):
         # XXX what does this return?
         return TypeRef(ffi.lib.LLVMPY_TypeOf(self))
 
+    @property
+    def global_value_type(self):
+        """
+        Uses ``LLVMGlobalGetValueType()``.
+        Needed for opaque pointers in globals.
+        > For globals, use getValueType().
+        See https://llvm.org/docs/OpaquePointers.html#migration-instructions
+        """
+        assert self.is_global or self.is_function
+        return TypeRef(ffi.lib.LLVMPY_GlobalGetValueType(self))
+
     @property
     def is_declaration(self):
         """
@@ -505,6 +516,9 @@ ffi.lib.LLVMPY_SetValueName.argtypes = [ffi.LLVMValueRef, c_char_p]
 ffi.lib.LLVMPY_TypeOf.argtypes = [ffi.LLVMValueRef]
 ffi.lib.LLVMPY_TypeOf.restype = ffi.LLVMTypeRef
 
+ffi.lib.LLVMPY_GlobalGetValueType.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_GlobalGetValueType.restype = ffi.LLVMTypeRef
+
 ffi.lib.LLVMPY_GetTypeName.argtypes = [ffi.LLVMTypeRef]
 ffi.lib.LLVMPY_GetTypeName.restype = c_void_p
 

llvmlite/ir/builder.py

@@ -753,7 +753,7 @@ class IRBuilder(object):
         self._insert(al)
         return al
 
-    def load(self, ptr, name='', align=None):
+    def load(self, ptr, name='', align=None, typ=None):
         """
         Load value from pointer, with optional guaranteed alignment:
             name = *ptr
@@ -761,7 +761,7 @@ class IRBuilder(object):
         if not isinstance(ptr.type, types.PointerType):
             msg = "cannot load from value of type %s (%r): not a pointer"
             raise TypeError(msg % (ptr.type, str(ptr)))
-        ld = instructions.LoadInstr(self.block, ptr, name)
+        ld = instructions.LoadInstr(self.block, ptr, name, typ=typ)
         ld.align = align
         self._insert(ld)
         return ld
@@ -774,7 +774,7 @@ class IRBuilder(object):
         if not isinstance(ptr.type, types.PointerType):
             msg = "cannot store to value of type %s (%r): not a pointer"
             raise TypeError(msg % (ptr.type, str(ptr)))
-        if ptr.type.pointee != value.type:
+        if not ptr.type.is_opaque and ptr.type.pointee != value.type:
             raise TypeError("cannot store %s to %s: mismatching types"
                             % (value.type, ptr.type))
         st = instructions.StoreInstr(self.block, value, ptr)
@@ -782,7 +782,7 @@ class IRBuilder(object):
         self._insert(st)
         return st
 
-    def load_atomic(self, ptr, ordering, align, name=''):
+    def load_atomic(self, ptr, ordering, align, name='', typ=None):
         """
         Load value from pointer, with optional guaranteed alignment:
             name = *ptr
@@ -791,7 +791,7 @@ class IRBuilder(object):
             msg = "cannot load from value of type %s (%r): not a pointer"
             raise TypeError(msg % (ptr.type, str(ptr)))
         ld = instructions.LoadAtomicInstr(
-            self.block, ptr, ordering, align, name)
+            self.block, ptr, ordering, align, name, typ=typ)
         self._insert(ld)
         return ld
 
@@ -919,13 +919,14 @@ class IRBuilder(object):
 
     # GEP APIs
 
-    def gep(self, ptr, indices, inbounds=False, name=''):
+    def gep(self, ptr, indices, inbounds=False, name='', source_etype=None):
         """
         Compute effective address (getelementptr):
             name = getelementptr ptr, <indices...>
         """
         instr = instructions.GEPInstr(self.block, ptr, indices,
-                                      inbounds=inbounds, name=name)
+                                      inbounds=inbounds, name=name,
+                                      source_etype=source_etype)
         self._insert(instr)
         return instr
 

llvmlite/ir/context.py

@@ -7,10 +7,10 @@ class Context(object):
         self.scope = _utils.NameScope()
         self.identified_types = {}
 
-    def get_identified_type(self, name):
+    def get_identified_type(self, name, packed=False):
         if name not in self.identified_types:
             self.scope.register(name)
-            ty = types.IdentifiedStructType(self, name)
+            ty = types.IdentifiedStructType(self, name, packed)
             self.identified_types[name] = ty
         else:
             ty = self.identified_types[name]

llvmlite/ir/instructions.py

@@ -431,9 +431,17 @@ class CastInstr(Instruction):
 
 class LoadInstr(Instruction):
 
-    def __init__(self, parent, ptr, name=''):
-        super(LoadInstr, self).__init__(parent, ptr.type.pointee, "load",
-                                        [ptr], name=name)
+    def __init__(self, parent, ptr, name='', typ=None):
+        if typ is None:
+            if isinstance(ptr, AllocaInstr):
+                typ = ptr.allocated_type
+            # For compatibility with typed pointers. Eventually this should
+            # probably be removed (when typed pointers are fully removed).
+            elif not ptr.type.is_opaque:
+                typ = ptr.type.pointee
+            else:
+                raise ValueError("Load lacks type.")
+        super(LoadInstr, self).__init__(parent, typ, "load", [ptr], name=name)
         self.align = None
 
     def descr(self, buf):
@@ -443,7 +451,7 @@ class LoadInstr(Instruction):
         else:
             align = ''
         buf.append("load {0}, {1} {2}{3}{4}\n".format(
-            val.type.pointee,
+            self.type,
             val.type,
             val.get_reference(),
             align,
@@ -473,16 +481,25 @@ class StoreInstr(Instruction):
 
 
 class LoadAtomicInstr(Instruction):
-    def __init__(self, parent, ptr, ordering, align, name=''):
-        super(LoadAtomicInstr, self).__init__(parent, ptr.type.pointee,
-                                              "load atomic", [ptr], name=name)
+    def __init__(self, parent, ptr, ordering, align, name='', typ=None):
+        if typ is None:
+            if isinstance(ptr, AllocaInstr):
+                typ = ptr.allocated_type
+            # For compatibility with typed pointers. Eventually this should
+            # probably be removed (when typed pointers are fully removed).
+            elif not ptr.type.is_opaque:
+                typ = ptr.type.pointee
+            else:
+                raise ValueError("Load atomic lacks type.")
+        super(LoadAtomicInstr, self).__init__(parent, typ, "load atomic",
+                                              [ptr], name=name)
         self.ordering = ordering
         self.align = align
 
     def descr(self, buf):
         [val] = self.operands
         buf.append("load atomic {0}, {1} {2} {3}, align {4}{5}\n".format(
-            val.type.pointee,
+            self.type,
             val.type,
             val.get_reference(),
             self.ordering,
@@ -516,10 +533,11 @@ class AllocaInstr(Instruction):
         operands = [count] if count else ()
         super(AllocaInstr, self).__init__(parent, typ.as_pointer(), "alloca",
                                           operands, name)
+        self.allocated_type = typ
         self.align = None
 
     def descr(self, buf):
-        buf.append("{0} {1}".format(self.opname, self.type.pointee))
+        buf.append("{0} {1}".format(self.opname, self.allocated_type))
         if self.operands:
             op, = self.operands
             buf.append(", {0} {1}".format(op.type, op.get_reference()))
@@ -530,22 +548,31 @@ class AllocaInstr(Instruction):
 
 
 class GEPInstr(Instruction):
-    def __init__(self, parent, ptr, indices, inbounds, name):
-        typ = ptr.type
-        lasttyp = None
-        lastaddrspace = 0
-        for i in indices:
-            lasttyp, typ = typ, typ.gep(i)
-            # inherit the addrspace from the last seen pointer
-            if isinstance(lasttyp, types.PointerType):
-                lastaddrspace = lasttyp.addrspace
-
-        if (not isinstance(typ, types.PointerType) and
-                isinstance(lasttyp, types.PointerType)):
-            typ = lasttyp
+    def __init__(self, parent, ptr, indices, inbounds, name,
+                 source_etype=None):
+        if source_etype is not None:
+            typ = ptr.type
+            self.source_etype = source_etype
+        # For compatibility with typed pointers. Eventually this should
+        # probably be removed (when typed pointers are fully removed).
+        elif not ptr.type.is_opaque:
+            typ = ptr.type
+            lasttyp = None
+            lastaddrspace = 0
+            for i in indices:
+                lasttyp, typ = typ, typ.gep(i)
+                # inherit the addrspace from the last seen pointer
+                if isinstance(lasttyp, types.PointerType):
+                    lastaddrspace = lasttyp.addrspace
+
+            if (not isinstance(typ, types.PointerType) and
+                    isinstance(lasttyp, types.PointerType)):
+                typ = lasttyp
+            else:
+                typ = typ.as_pointer(lastaddrspace)
+            self.source_etype = ptr.type.pointee
         else:
-            typ = typ.as_pointer(lastaddrspace)
-
+            raise ValueError("GEP lacks type.")
         super(GEPInstr, self).__init__(parent, typ, "getelementptr",
                                        [ptr] + list(indices), name=name)
         self.pointer = ptr
@@ -558,7 +585,7 @@ class GEPInstr(Instruction):
         op = "getelementptr inbounds" if self.inbounds else "getelementptr"
         buf.append("{0} {1}, {2} {3}, {4} {5}\n".format(
                    op,
-                   self.pointer.type.pointee,
+                   self.source_etype,
                    self.pointer.type,
                    self.pointer.get_reference(),
                    ', '.join(indices),

llvmlite/ir/types.py

@@ -6,6 +6,9 @@ import struct
 
 from llvmlite.ir._utils import _StrCaching
 
+# FIXME: Remove me once typed pointers are no longer supported.
+from llvmlite import opaque_pointers_enabled
+
 
 def _wrapname(x):
     return '"{0}"'.format(x.replace('\\', '\\5c').replace('"', '\\22'))
@@ -30,7 +33,7 @@ class Type(_StrCaching):
     def __ne__(self, other):
         return not (self == other)
 
-    def _get_ll_pointer_type(self, target_data, context=None):
+    def _get_ll_global_value_type(self, target_data, context=None):
         """
         Convert this type object to an LLVM type.
         """
@@ -43,22 +46,26 @@ class Type(_StrCaching):
             m = Module(context=context)
         foo = GlobalVariable(m, self, name="foo")
         with parse_assembly(str(m)) as llmod:
-            return llmod.get_global_variable(foo.name).type
+            return llmod.get_global_variable(foo.name).global_value_type
 
     def get_abi_size(self, target_data, context=None):
         """
         Get the ABI size of this type according to data layout *target_data*.
         """
-        llty = self._get_ll_pointer_type(target_data, context)
-        return target_data.get_pointee_abi_size(llty)
+        llty = self._get_ll_global_value_type(target_data, context)
+        return target_data.get_abi_size(llty)
+
+    def get_element_offset(self, target_data, ndx, context=None):
+        llty = self._get_ll_global_value_type(target_data, context)
+        return target_data.get_element_offset(llty, ndx)
 
     def get_abi_alignment(self, target_data, context=None):
         """
         Get the minimum ABI alignment of this type according to data layout
         *target_data*.
         """
-        llty = self._get_ll_pointer_type(target_data, context)
-        return target_data.get_pointee_abi_alignment(llty)
+        llty = self._get_ll_global_value_type(target_data, context)
+        return target_data.get_abi_alignment(llty)
 
     def format_constant(self, value):
         """
@@ -109,30 +116,67 @@ class LabelType(Type):
 class PointerType(Type):
     """
     The type of all pointer values.
+    By default (without specialisation) represents an opaque pointer.
     """
+    is_opaque = True
     is_pointer = True
     null = 'null'
 
-    def __init__(self, pointee, addrspace=0):
-        assert not isinstance(pointee, VoidType)
-        self.pointee = pointee
+    # Factory to create typed or opaque pointers based on `pointee'.
+    def __new__(cls, pointee=None, addrspace=0):
+        if cls is PointerType and pointee is not None:
+            return super().__new__(_TypedPointerType)
+        return super(PointerType, cls).__new__(cls)
+
+    def __init__(self, addrspace=0):
         self.addrspace = addrspace
 
     def _to_string(self):
         if self.addrspace != 0:
-            return "{0} addrspace({1})*".format(self.pointee, self.addrspace)
+            return "ptr addrspace({0})".format(self.addrspace)
         else:
-            return "{0}*".format(self.pointee)
+            return "ptr"
+
+    def __hash__(self):
+        return hash(PointerType)
+
+    @classmethod
+    def from_llvm(cls, typeref, ir_ctx):
+        """
+        Create from a llvmlite.binding.TypeRef
+        """
+        if not opaque_pointers_enabled:
+            return _TypedPointerType.from_llvm(typeref, ir_ctx)
+        return cls()
+
+
+class _TypedPointerType(PointerType):
+    """
+    The type of typed pointer values. To be removed eventually.
+    """
+
+    def __init__(self, pointee, addrspace=0):
+        super(_TypedPointerType, self).__init__(addrspace)
+        assert pointee is not None
+        assert not isinstance(pointee, VoidType)
+        self.pointee = pointee
+        self.is_opaque = False
+
+    def _to_string(self):
+        if not opaque_pointers_enabled:
+            return "{0}*".format(self.pointee) if self.addrspace == 0 else \
+                   "{0} addrspace({1})*".format(self.pointee, self.addrspace)
+        return super(_TypedPointerType, self)._to_string()
 
+    # This implements ``isOpaqueOrPointeeTypeEquals''.
     def __eq__(self, other):
-        if isinstance(other, PointerType):
+        if isinstance(other, _TypedPointerType):
             return (self.pointee, self.addrspace) == (other.pointee,
                                                       other.addrspace)
-        else:
-            return False
+        return isinstance(other, PointerType)
 
     def __hash__(self):
-        return hash(PointerType)
+        return hash(_TypedPointerType)
 
     def gep(self, i):
         """
@@ -146,6 +190,17 @@ class PointerType(Type):
     def intrinsic_name(self):
         return 'p%d%s' % (self.addrspace, self.pointee.intrinsic_name)
 
+    @classmethod
+    def from_llvm(cls, typeref, ir_ctx):
+        """
+        Create from a llvmlite.binding.TypeRef
+        """
+        assert not opaque_pointers_enabled
+        # opaque pointer will change this
+        [pointee] = typeref.elements
+        # addrspace is not handled
+        return cls(pointee.as_ir(ir_ctx=ir_ctx))
+
 
 class VoidType(Type):
     """
@@ -161,6 +216,13 @@ class VoidType(Type):
     def __hash__(self):
         return hash(VoidType)
 
+    @classmethod
+    def from_llvm(cls, typeref, ir_ctx):
+        """
+        Create from a llvmlite.binding.TypeRef
+        """
+        return cls()
+
 
 class FunctionType(Type):
     """
@@ -194,6 +256,17 @@ class FunctionType(Type):
     def __hash__(self):
         return hash(FunctionType)
 
+    @classmethod
+    def from_llvm(cls, typeref, ir_ctx):
+        """
+        Create from a llvmlite.binding.TypeRef
+        """
+        params = tuple(x.as_ir(ir_ctx=ir_ctx)
+                       for x in typeref.get_function_parameters())
+        ret = typeref.get_function_return().as_ir(ir_ctx=ir_ctx)
+        is_vararg = typeref.is_function_vararg
+        return cls(ret, params, is_vararg)
+
 
 class IntType(Type):
     """
@@ -253,6 +326,13 @@ class IntType(Type):
     def intrinsic_name(self):
         return str(self)
 
+    @classmethod
+    def from_llvm(cls, typeref, ir_ctx):
+        """
+        Create from a llvmlite.binding.TypeRef
+        """
+        return IntType(typeref.type_width)
+
 
 def _as_float(value):
     """
@@ -302,6 +382,13 @@ class _BaseFloatType(Type):
     def _create_instance(cls):
         cls._instance_cache = super(_BaseFloatType, cls).__new__(cls)
 
+    @classmethod
+    def from_llvm(cls, typeref, ir_ctx):
+        """
+        Create from a llvmlite.binding.TypeRef
+        """
+        return cls()
+
 
 class HalfType(_BaseFloatType):
     """
@@ -414,6 +501,16 @@ class VectorType(Type):
         return [Constant(ty, val) if not isinstance(val, Value) else val
                 for ty, val in zip(self.elements, values)]
 
+    @classmethod
+    def from_llvm(cls, typeref, ir_ctx):
+        """
+        Create from a llvmlite.binding.TypeRef
+        """
+        [elemtyperef] = typeref.elements
+        elemty = elemtyperef.as_ir(ir_ctx=ir_ctx)
+        count = typeref.element_count
+        return cls(elemty, count)
+
 
 class Aggregate(Type):
     """
@@ -472,6 +569,16 @@ class ArrayType(Aggregate):
                                  for x in value])
         return "[{0}]".format(itemstring)
 
+    @classmethod
+    def from_llvm(cls, typeref, ir_ctx):
+        """
+        Create from a llvmlite.binding.TypeRef
+        """
+        [elemtyperef] = typeref.elements
+        elemty = elemtyperef.as_ir(ir_ctx=ir_ctx)
+        count = typeref.element_count
+        return cls(elemty, count)
+
 
 class BaseStructType(Aggregate):
     """
@@ -536,6 +643,17 @@ class BaseStructType(Aggregate):
         else:
             return textrepr
 
+    @classmethod
+    def from_llvm(cls, typeref, ir_ctx):
+        """
+        Create from a llvmlite.binding.TypeRef
+        """
+        if typeref.is_literal_struct:
+            elems = [el.as_ir(ir_ctx=ir_ctx) for el in typeref.elements]
+            return cls(elems, typeref.is_packed_struct)
+        else:
+            return ir_ctx.get_identified_type(typeref.name)
+
 
 class LiteralStructType(BaseStructType):
     """
@@ -558,7 +676,8 @@ class LiteralStructType(BaseStructType):
 
     def __eq__(self, other):
         if isinstance(other, LiteralStructType):
-            return self.elements == other.elements
+            return (self.elements == other.elements
+                    and self.packed == other.packed)
 
     def __hash__(self):
         return hash(LiteralStructType)
@@ -602,7 +721,8 @@ class IdentifiedStructType(BaseStructType):
 
     def __eq__(self, other):
         if isinstance(other, IdentifiedStructType):
-            return self.name == other.name
+            return (self.name == other.name
+                    and self.packed == other.packed)
 
     def __hash__(self):
         return hash(IdentifiedStructType)

llvmlite/ir/values.py

@@ -482,12 +482,12 @@ class Constant(_StrCaching, _StringReferenceCaching, _ConstOpMixin, Value):
         return cls(types.ArrayType(ty, len(elems)), elems)
 
     @classmethod
-    def literal_struct(cls, elems):
+    def literal_struct(cls, elems, packed=False):
         """
         Construct a literal structure constant made of the given members.
         """
         tys = [el.type for el in elems]
-        return cls(types.LiteralStructType(tys), elems)
+        return cls(types.LiteralStructType(tys, packed), elems)
 
     @property
     def addrspace(self):