llvmlite 0.41.1__cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 0.42.0__cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

llvmlite/_version.py

@@ -4,8 +4,8 @@
 # unpacked source archive. Distribution tarballs contain a pre-generated copy
 # of this file.
 
-version_version = '0.41.1'
-version_full = '42db9b74c8e8ca012cb4394cbf941f2f9e4ae12b'
+version_version = '0.42.0'
+version_full = 'b2a26aafd266b8972ad26dfa98dc41642f84913e'
 def get_versions(default={}, verbose=False):
     return {'version': version_version, 'full': version_full}
 

llvmlite/binding/__init__.py

@@ -11,6 +11,7 @@ from .passmanagers import *
 from .targets import *
 from .transforms import *
 from .value import *
+from .typeref import *
 from .analysis import *
 from .object_file import *
 from .context import *

llvmlite/binding/executionengine.py

@@ -1,3 +1,4 @@
+import platform
 from ctypes import (POINTER, c_char_p, c_bool, c_void_p,
                     c_int, c_uint64, c_size_t, CFUNCTYPE, string_at, cast,
                     py_object, Structure)
@@ -9,14 +10,21 @@ from llvmlite.binding import ffi, targets, object_file
 ffi.lib.LLVMPY_LinkInMCJIT
 
 
-def create_mcjit_compiler(module, target_machine):
+def create_mcjit_compiler(module, target_machine, use_lmm=None):
     """
     Create a MCJIT ExecutionEngine from the given *module* and
     *target_machine*.
+
+    *lmm* controls whether the llvmlite memory manager is used. If not supplied,
+    the default choice for the platform will be used (``True`` on 64-bit ARM
+    systems, ``False`` otherwise).
     """
+    if use_lmm is None:
+        use_lmm = platform.machine() in ('arm64', 'aarch64')
+
     with ffi.OutputString() as outerr:
         engine = ffi.lib.LLVMPY_CreateMCJITCompiler(
-            module, target_machine, outerr)
+            module, target_machine, use_lmm, outerr)
         if not engine:
             raise RuntimeError(str(outerr))
 
@@ -71,7 +79,6 @@ class ExecutionEngine(ffi.ObjectRef):
         return ffi.lib.LLVMPY_GetGlobalValueAddress(self, name.encode("ascii"))
 
     def add_global_mapping(self, gv, addr):
-        # XXX unused?
         ffi.lib.LLVMPY_AddGlobalMapping(self, gv, addr)
 
     def add_module(self, module):
@@ -239,6 +246,7 @@ class _ObjectCacheRef(ffi.ObjectRef):
 ffi.lib.LLVMPY_CreateMCJITCompiler.argtypes = [
     ffi.LLVMModuleRef,
     ffi.LLVMTargetMachineRef,
+    c_bool,
     POINTER(c_char_p),
 ]
 ffi.lib.LLVMPY_CreateMCJITCompiler.restype = ffi.LLVMExecutionEngineRef

llvmlite/binding/ffi.py

@@ -25,6 +25,7 @@ LLVMTargetRef = _make_opaque_ref("LLVMTarget")
 LLVMTargetMachineRef = _make_opaque_ref("LLVMTargetMachine")
 LLVMMemoryBufferRef = _make_opaque_ref("LLVMMemoryBuffer")
 LLVMAttributeListIterator = _make_opaque_ref("LLVMAttributeListIterator")
+LLVMElementIterator = _make_opaque_ref("LLVMElementIterator")
 LLVMAttributeSetIterator = _make_opaque_ref("LLVMAttributeSetIterator")
 LLVMGlobalsIterator = _make_opaque_ref("LLVMGlobalsIterator")
 LLVMFunctionsIterator = _make_opaque_ref("LLVMFunctionsIterator")
@@ -32,6 +33,7 @@ LLVMBlocksIterator = _make_opaque_ref("LLVMBlocksIterator")
 LLVMArgumentsIterator = _make_opaque_ref("LLVMArgumentsIterator")
 LLVMInstructionsIterator = _make_opaque_ref("LLVMInstructionsIterator")
 LLVMOperandsIterator = _make_opaque_ref("LLVMOperandsIterator")
+LLVMIncomingBlocksIterator = _make_opaque_ref("LLVMIncomingBlocksIterator")
 LLVMTypesIterator = _make_opaque_ref("LLVMTypesIterator")
 LLVMObjectCacheRef = _make_opaque_ref("LLVMObjectCache")
 LLVMObjectFileRef = _make_opaque_ref("LLVMObjectFile")

llvmlite/binding/passmanagers.py

@@ -638,6 +638,14 @@ class PassManager(ffi.ObjectRef):
     def add_target_library_info(self, triple):
         ffi.lib.LLVMPY_AddTargetLibraryInfoPass(self, _encode_string(triple))
 
+    def add_instruction_namer_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#instnamer-assign-names-to-anonymous-instructions.
+
+        LLVM 14: `llvm::createInstructionNamerPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddInstructionNamerPass(self)
+
     # Non-standard LLVM passes
 
     def add_refprune_pass(self, subpasses_flags=RefPruneSubpasses.ALL,
@@ -916,6 +924,7 @@ ffi.lib.LLVMPY_AddTypeBasedAliasAnalysisPass.argtypes = [ffi.LLVMPassManagerRef]
 ffi.lib.LLVMPY_AddBasicAliasAnalysisPass.argtypes = [ffi.LLVMPassManagerRef]
 ffi.lib.LLVMPY_AddTargetLibraryInfoPass.argtypes = [ffi.LLVMPassManagerRef,
                                                     c_char_p]
+ffi.lib.LLVMPY_AddInstructionNamerPass.argtypes = [ffi.LLVMPassManagerRef]
 
 ffi.lib.LLVMPY_AddRefPrunePass.argtypes = [ffi.LLVMPassManagerRef, c_int,
                                            c_size_t]

llvmlite/binding/typeref.py

@@ -0,0 +1,198 @@
+from ctypes import c_int, c_bool, c_void_p, c_uint64
+import enum
+
+from llvmlite.binding import ffi
+
+
+class TypeKind(enum.IntEnum):
+    # The LLVMTypeKind enum from llvm-c/Core.h
+
+    void = 0
+    half = 1
+    float = 2
+    double = 3
+    x86_fp80 = 4
+    fp128 = 5
+    ppc_fp128 = 6
+    label = 7
+    integer = 8
+    function = 9
+    struct = 10
+    array = 11
+    pointer = 12
+    vector = 13
+    metadata = 14
+    x86_mmx = 15
+    token = 16
+    scalable_vector = 17
+    bfloat = 18
+    x86_amx = 19
+
+
+class TypeRef(ffi.ObjectRef):
+    """A weak reference to a LLVM type
+    """
+    @property
+    def name(self):
+        """
+        Get type name
+        """
+        return ffi.ret_string(ffi.lib.LLVMPY_GetTypeName(self))
+
+    @property
+    def is_struct(self):
+        """
+        Returns true if the type is a struct type.
+        """
+        return ffi.lib.LLVMPY_TypeIsStruct(self)
+
+    @property
+    def is_pointer(self):
+        """
+        Returns true if the type is a pointer type.
+        """
+        return ffi.lib.LLVMPY_TypeIsPointer(self)
+
+    @property
+    def is_array(self):
+        """
+        Returns true if the type is an array type.
+        """
+        return ffi.lib.LLVMPY_TypeIsArray(self)
+
+    @property
+    def is_vector(self):
+        """
+        Returns true if the type is a vector type.
+        """
+        return ffi.lib.LLVMPY_TypeIsVector(self)
+
+    @property
+    def is_function_vararg(self):
+        """
+        Returns true if a function type accepts a variable number of arguments.
+        When the type is not a function, raises exception.
+        """
+        if self.type_kind != TypeKind.function:
+            raise ValueError("Type {} is not a function".format(self))
+        return ffi.lib.LLVMPY_IsFunctionVararg(self)
+
+    @property
+    def elements(self):
+        """
+        Returns iterator over enclosing types
+        """
+        return _TypeListIterator(ffi.lib.LLVMPY_ElementIter(self))
+
+    @property
+    def element_type(self):
+        """
+        Returns the pointed-to type. When the type is not a pointer,
+        raises exception.
+        """
+        if not self.is_pointer:
+            raise ValueError("Type {} is not a pointer".format(self))
+        return TypeRef(ffi.lib.LLVMPY_GetElementType(self))
+
+    @property
+    def element_count(self):
+        """
+        Returns the number of elements in an array or a vector. For scalable
+        vectors, returns minimum number of elements. When the type is neither
+        an array nor a vector, raises exception.
+        """
+        if not self.is_array and not self.is_vector:
+            raise ValueError("Type {} is not an array nor vector".format(self))
+        return ffi.lib.LLVMPY_GetTypeElementCount(self)
+
+    @property
+    def type_width(self):
+        """
+        Return the basic size of this type if it is a primitive type. These are
+        fixed by LLVM and are not target-dependent.
+        This will return zero if the type does not have a size or is not a
+        primitive type.
+
+        If this is a scalable vector type, the scalable property will be set and
+        the runtime size will be a positive integer multiple of the base size.
+
+        Note that this may not reflect the size of memory allocated for an
+        instance of the type or the number of bytes that are written when an
+        instance of the type is stored to memory.
+        """
+        return ffi.lib.LLVMPY_GetTypeBitWidth(self)
+
+    @property
+    def type_kind(self):
+        """
+        Returns the LLVMTypeKind enumeration of this type.
+        """
+        return TypeKind(ffi.lib.LLVMPY_GetTypeKind(self))
+
+    def __str__(self):
+        return ffi.ret_string(ffi.lib.LLVMPY_PrintType(self))
+
+
+class _TypeIterator(ffi.ObjectRef):
+
+    def __next__(self):
+        vp = self._next()
+        if vp:
+            return TypeRef(vp)
+        else:
+            raise StopIteration
+
+    next = __next__
+
+    def __iter__(self):
+        return self
+
+
+class _TypeListIterator(_TypeIterator):
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeElementIter(self)
+
+    def _next(self):
+        return ffi.lib.LLVMPY_ElementIterNext(self)
+
+
+# FFI
+
+ffi.lib.LLVMPY_PrintType.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_PrintType.restype = c_void_p
+
+ffi.lib.LLVMPY_GetElementType.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_GetElementType.restype = ffi.LLVMTypeRef
+
+ffi.lib.LLVMPY_TypeIsPointer.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_TypeIsPointer.restype = c_bool
+
+ffi.lib.LLVMPY_TypeIsArray.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_TypeIsArray.restype = c_bool
+
+ffi.lib.LLVMPY_TypeIsVector.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_TypeIsVector.restype = c_bool
+
+ffi.lib.LLVMPY_TypeIsStruct.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_TypeIsStruct.restype = c_bool
+
+ffi.lib.LLVMPY_IsFunctionVararg.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_IsFunctionVararg.restype = c_bool
+
+ffi.lib.LLVMPY_GetTypeKind.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_GetTypeKind.restype = c_int
+
+ffi.lib.LLVMPY_GetTypeElementCount.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_GetTypeElementCount.restype = c_int
+
+ffi.lib.LLVMPY_GetTypeBitWidth.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_GetTypeBitWidth.restype = c_uint64
+
+ffi.lib.LLVMPY_ElementIter.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_ElementIter.restype = ffi.LLVMElementIterator
+
+ffi.lib.LLVMPY_ElementIterNext.argtypes = [ffi.LLVMElementIterator]
+ffi.lib.LLVMPY_ElementIterNext.restype = ffi.LLVMTypeRef
+
+ffi.lib.LLVMPY_DisposeElementIter.argtypes = [ffi.LLVMElementIterator]

llvmlite/binding/value.py

@@ -4,6 +4,7 @@ import enum
 
 from llvmlite.binding import ffi
 from llvmlite.binding.common import _decode_string, _encode_string
+from llvmlite.binding.typeref import TypeRef
 
 
 class Linkage(enum.IntEnum):
@@ -79,37 +80,6 @@ class ValueKind(enum.IntEnum):
     poison_value = 25
 
 
-class TypeRef(ffi.ObjectRef):
-    """A weak reference to a LLVM type
-    """
-    @property
-    def name(self):
-        """
-        Get type name
-        """
-        return ffi.ret_string(ffi.lib.LLVMPY_GetTypeName(self))
-
-    @property
-    def is_pointer(self):
-        """
-        Returns true is the type is a pointer type.
-        """
-        return ffi.lib.LLVMPY_TypeIsPointer(self)
-
-    @property
-    def element_type(self):
-        """
-        Returns the pointed-to type. When the type is not a pointer,
-        raises exception.
-        """
-        if not self.is_pointer:
-            raise ValueError("Type {} is not a pointer".format(self))
-        return TypeRef(ffi.lib.LLVMPY_GetElementType(self))
-
-    def __str__(self):
-        return ffi.ret_string(ffi.lib.LLVMPY_PrintType(self))
-
-
 class ValueRef(ffi.ObjectRef):
     """A weak reference to a LLVM value.
     """
@@ -343,6 +313,20 @@ class ValueRef(ffi.ObjectRef):
                              % (self._kind,))
         return ffi.ret_string(ffi.lib.LLVMPY_GetOpcodeName(self))
 
+    @property
+    def incoming_blocks(self):
+        """
+        Return an iterator over this phi instruction's incoming blocks.
+        The iterator will yield a ValueRef for each block.
+        """
+        if not self.is_instruction or self.opcode != 'phi':
+            raise ValueError('expected phi instruction value, got %s'
+                             % (self._kind,))
+        it = ffi.lib.LLVMPY_PhiIncomingBlocksIter(self)
+        parents = self._parents.copy()
+        parents.update(instruction=self)
+        return _IncomingBlocksIterator(it, parents)
+
     def get_constant_value(self, signed_int=False, round_fp=False):
         """
         Return the constant value, either as a literal (when supported)
@@ -492,6 +476,17 @@ class _OperandsIterator(_ValueIterator):
         return ffi.lib.LLVMPY_OperandsIterNext(self)
 
 
+class _IncomingBlocksIterator(_ValueIterator):
+
+    kind = 'block'
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeIncomingBlocksIter(self)
+
+    def _next(self):
+        return ffi.lib.LLVMPY_IncomingBlocksIterNext(self)
+
+
 # FFI
 
 ffi.lib.LLVMPY_PrintValueToString.argtypes = [
@@ -510,17 +505,6 @@ 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_PrintType.argtypes = [ffi.LLVMTypeRef]
-ffi.lib.LLVMPY_PrintType.restype = c_void_p
-
-ffi.lib.LLVMPY_TypeIsPointer.argtypes = [ffi.LLVMTypeRef]
-ffi.lib.LLVMPY_TypeIsPointer.restype = c_bool
-
-ffi.lib.LLVMPY_GetElementType.argtypes = [ffi.LLVMTypeRef]
-ffi.lib.LLVMPY_GetElementType.restype = ffi.LLVMTypeRef
-
-
 ffi.lib.LLVMPY_GetTypeName.argtypes = [ffi.LLVMTypeRef]
 ffi.lib.LLVMPY_GetTypeName.restype = c_void_p
 
@@ -574,6 +558,9 @@ ffi.lib.LLVMPY_BlockInstructionsIter.restype = ffi.LLVMInstructionsIterator
 ffi.lib.LLVMPY_InstructionOperandsIter.argtypes = [ffi.LLVMValueRef]
 ffi.lib.LLVMPY_InstructionOperandsIter.restype = ffi.LLVMOperandsIterator
 
+ffi.lib.LLVMPY_PhiIncomingBlocksIter.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_PhiIncomingBlocksIter.restype = ffi.LLVMIncomingBlocksIterator
+
 ffi.lib.LLVMPY_DisposeAttributeListIter.argtypes = [
     ffi.LLVMAttributeListIterator]
 
@@ -585,6 +572,9 @@ ffi.lib.LLVMPY_DisposeInstructionsIter.argtypes = [ffi.LLVMInstructionsIterator]
 
 ffi.lib.LLVMPY_DisposeOperandsIter.argtypes = [ffi.LLVMOperandsIterator]
 
+ffi.lib.LLVMPY_DisposeIncomingBlocksIter.argtypes = [
+    ffi.LLVMIncomingBlocksIterator]
+
 ffi.lib.LLVMPY_AttributeListIterNext.argtypes = [ffi.LLVMAttributeListIterator]
 ffi.lib.LLVMPY_AttributeListIterNext.restype = c_void_p
 
@@ -603,6 +593,10 @@ ffi.lib.LLVMPY_InstructionsIterNext.restype = ffi.LLVMValueRef
 ffi.lib.LLVMPY_OperandsIterNext.argtypes = [ffi.LLVMOperandsIterator]
 ffi.lib.LLVMPY_OperandsIterNext.restype = ffi.LLVMValueRef
 
+ffi.lib.LLVMPY_IncomingBlocksIterNext.argtypes = [
+    ffi.LLVMIncomingBlocksIterator]
+ffi.lib.LLVMPY_IncomingBlocksIterNext.restype = ffi.LLVMValueRef
+
 ffi.lib.LLVMPY_GetOpcodeName.argtypes = [ffi.LLVMValueRef]
 ffi.lib.LLVMPY_GetOpcodeName.restype = c_void_p
 

llvmlite/ir/instructions.py

@@ -52,8 +52,8 @@ class Instruction(NamedValue, _HasMetadata):
 
 
 class CallInstrAttributes(AttributeSet):
-    _known = frozenset(['noreturn', 'nounwind', 'readonly', 'readnone',
-                        'noinline', 'alwaysinline'])
+    _known = frozenset(['convergent', 'noreturn', 'nounwind', 'readonly',
+                        'readnone', 'noinline', 'alwaysinline'])
 
 
 TailMarkerOptions = frozenset(['tail', 'musttail', 'notail'])

llvmlite/ir/values.py

@@ -878,7 +878,7 @@ class AttributeSet(set):
 
 class FunctionAttributes(AttributeSet):
     _known = frozenset([
-        'argmemonly', 'alwaysinline', 'builtin', 'cold',
+        'argmemonly', 'alwaysinline', 'builtin', 'cold', 'convergent',
         'inaccessiblememonly', 'inaccessiblemem_or_argmemonly', 'inlinehint',
         'jumptable', 'minsize', 'naked', 'nobuiltin', 'noduplicate',
         'noimplicitfloat', 'noinline', 'nonlazybind', 'norecurse',

llvmlite/tests/test_binding.py

@@ -41,6 +41,7 @@ asm_sum = r"""
     source_filename = "asm_sum.c"
     target triple = "{triple}"
     %struct.glob_type = type {{ i64, [2 x i64]}}
+    %struct.glob_type_vec = type {{ i64, <2 x i64>}}
 
     @glob = global i32 0
     @glob_b = global i8 0
@@ -144,6 +145,13 @@ asm_sum_declare = r"""
     declare i32 @sum(i32 %.1, i32 %.2)
     """
 
+asm_vararg_declare = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    declare i32 @vararg(i32 %.1, ...)
+    """
+
 asm_double_inaccurate = r"""
     ; ModuleID = '<string>'
     target triple = "{triple}"
@@ -494,6 +502,26 @@ entry:
 }
 """  # noqa E501
 
+asm_phi_blocks = r"""
+; ModuleID = '<string>'
+target triple = "{triple}"
+
+define void @foo(i32 %N) {{
+  ; unnamed block for testing
+  %cmp4 = icmp sgt i32 %N, 0
+  br i1 %cmp4, label %for.body, label %for.cond.cleanup
+
+for.cond.cleanup:
+  ret void
+
+for.body:
+  %i.05 = phi i32 [ %inc, %for.body ], [ 0, %0 ]
+  %inc = add nuw nsw i32 %i.05, 1
+  %exitcond.not = icmp eq i32 %inc, %N
+  br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
+}}
+"""
+
 
 class BaseTest(TestCase):
 
@@ -547,7 +575,7 @@ class TestDependencies(BaseTest):
         out, _ = p.communicate()
         self.assertEqual(0, p.returncode)
         # Parse library dependencies
-        lib_pat = re.compile(r'^([-_a-zA-Z0-9]+)\.so(?:\.\d+){0,3}$')
+        lib_pat = re.compile(r'^([+-_a-zA-Z0-9]+)\.so(?:\.\d+){0,3}$')
         deps = set()
         for line in out.decode().splitlines():
             parts = line.split()
@@ -1685,6 +1713,112 @@ class TestValueRef(BaseTest):
         self.assertTrue(arg.is_constant)
         self.assertEqual(arg.get_constant_value(), 'i64* null')
 
+    def test_incoming_phi_blocks(self):
+        mod = self.module(asm_phi_blocks)
+        func = mod.get_function('foo')
+        blocks = list(func.blocks)
+        instructions = list(blocks[-1].instructions)
+        self.assertTrue(instructions[0].is_instruction)
+        self.assertEqual(instructions[0].opcode, 'phi')
+
+        incoming_blocks = list(instructions[0].incoming_blocks)
+        self.assertEqual(len(incoming_blocks), 2)
+        self.assertTrue(incoming_blocks[0].is_block)
+        self.assertTrue(incoming_blocks[1].is_block)
+        # Test reference to blocks (named or unnamed)
+        self.assertEqual(incoming_blocks[0], blocks[-1])
+        self.assertEqual(incoming_blocks[1], blocks[0])
+
+        # Test case that should fail
+        self.assertNotEqual(instructions[1].opcode, 'phi')
+        with self.assertRaises(ValueError):
+            instructions[1].incoming_blocks
+
+
+class TestTypeRef(BaseTest):
+
+    def test_str(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        self.assertEqual(str(glob.type), "i32*")
+        glob_struct_type = mod.get_struct_type("struct.glob_type")
+        self.assertEqual(str(glob_struct_type),
+                         "%struct.glob_type = type { i64, [2 x i64] }")
+
+        elements = list(glob_struct_type.elements)
+        self.assertEqual(len(elements), 2)
+        self.assertEqual(str(elements[0]), "i64")
+        self.assertEqual(str(elements[1]), "[2 x i64]")
+
+    def test_type_kind(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        self.assertEqual(glob.type.type_kind, llvm.TypeKind.pointer)
+        self.assertTrue(glob.type.is_pointer)
+
+        glob_struct = mod.get_global_variable("glob_struct")
+        self.assertEqual(glob_struct.type.type_kind, llvm.TypeKind.pointer)
+        self.assertTrue(glob_struct.type.is_pointer)
+
+        stype = next(iter(glob_struct.type.elements))
+        self.assertEqual(stype.type_kind, llvm.TypeKind.struct)
+        self.assertTrue(stype.is_struct)
+
+        stype_a, stype_b = stype.elements
+        self.assertEqual(stype_a.type_kind, llvm.TypeKind.integer)
+        self.assertEqual(stype_b.type_kind, llvm.TypeKind.array)
+        self.assertTrue(stype_b.is_array)
+
+        glob_vec_struct_type = mod.get_struct_type("struct.glob_type_vec")
+        _, vector_type = glob_vec_struct_type.elements
+        self.assertEqual(vector_type.type_kind, llvm.TypeKind.vector)
+        self.assertTrue(vector_type.is_vector)
+
+        funcptr = mod.get_function("sum").type
+        self.assertEqual(funcptr.type_kind, llvm.TypeKind.pointer)
+        functype, = funcptr.elements
+        self.assertEqual(functype.type_kind, llvm.TypeKind.function)
+
+    def test_element_count(self):
+        mod = self.module()
+        glob_struct_type = mod.get_struct_type("struct.glob_type")
+        _, array_type = glob_struct_type.elements
+        self.assertEqual(array_type.element_count, 2)
+        with self.assertRaises(ValueError):
+            glob_struct_type.element_count
+
+    def test_type_width(self):
+        mod = self.module()
+        glob_struct_type = mod.get_struct_type("struct.glob_type")
+        glob_vec_struct_type = mod.get_struct_type("struct.glob_type_vec")
+        integer_type, array_type = glob_struct_type.elements
+        _, vector_type = glob_vec_struct_type.elements
+        self.assertEqual(integer_type.type_width, 64)
+        self.assertEqual(vector_type.type_width, 64 * 2)
+
+        # Structs and arrays are not primitive types
+        self.assertEqual(glob_struct_type.type_width, 0)
+        self.assertEqual(array_type.type_width, 0)
+
+    def test_vararg_function(self):
+        # Variadic function
+        mod = self.module(asm_vararg_declare)
+        func = mod.get_function('vararg')
+        decltype = func.type.element_type
+        self.assertTrue(decltype.is_function_vararg)
+
+        mod = self.module(asm_sum_declare)
+        func = mod.get_function('sum')
+        decltype = func.type.element_type
+        self.assertFalse(decltype.is_function_vararg)
+
+        # test that the function pointer type cannot use is_function_vararg
+        self.assertTrue(func.type.is_pointer)
+        with self.assertRaises(ValueError) as raises:
+            func.type.is_function_vararg
+        self.assertIn("Type i32 (i32, i32)* is not a function",
+                      str(raises.exception))
+
 
 class TestTarget(BaseTest):
 
@@ -2087,6 +2221,7 @@ class TestPasses(BaseTest, PassManagerTestMixin):
         pm.add_lint_pass()
         pm.add_module_debug_info_pass()
         pm.add_refprune_pass()
+        pm.add_instruction_namer_pass()
 
     @unittest.skipUnless(platform.machine().startswith("x86"), "x86 only")
     def test_target_library_info_behavior(self):
@@ -2114,6 +2249,22 @@ class TestPasses(BaseTest, PassManagerTestMixin):
         self.assertNotIn("call float @llvm.exp2.f32", str(mod))
         self.assertIn("call float @ldexpf", str(mod))
 
+    def test_instruction_namer_pass(self):
+        asm = asm_inlineasm3.format(triple=llvm.get_default_triple())
+        mod = llvm.parse_assembly(asm)
+
+        # Run instnamer pass
+        pm = llvm.ModulePassManager()
+        pm.add_instruction_namer_pass()
+        pm.run(mod)
+
+        # Test that unnamed instructions are now named
+        func = mod.get_function('foo')
+        first_block = next(func.blocks)
+        instructions = list(first_block.instructions)
+        self.assertEqual(instructions[0].name, 'i')
+        self.assertEqual(instructions[1].name, 'i2')
+
 
 class TestDylib(BaseTest):
 

llvmlite/tests/test_ir.py

@@ -133,13 +133,15 @@ class TestFunction(TestBase):
         func = self.function()
         func.attributes.add("optsize")
         func.attributes.add("alwaysinline")
+        func.attributes.add("convergent")
         func.attributes.alignstack = 16
         tp_pers = ir.FunctionType(int8, (), var_arg=True)
         pers = ir.Function(self.module(), tp_pers, '__gxx_personality_v0')
         func.attributes.personality = pers
         asm = self.descr(func).strip()
         self.assertEqual(asm,
-                         ("declare %s alwaysinline optsize alignstack(16) "
+                         ("declare %s alwaysinline convergent optsize "
+                          "alignstack(16) "
                           "personality i8 (...)* @\"__gxx_personality_v0\"") %
                          self.proto)
         # Check pickling
@@ -1322,6 +1324,7 @@ my_block:
         builder.call(f, (a, b), 'res_alwaysinline', attrs='alwaysinline')
         builder.call(f, (a, b), 'res_noinline_ro', attrs=('noinline',
                                                           'readonly'))
+        builder.call(f, (a, b), 'res_convergent', attrs='convergent')
         self.check_block(block, """\
         my_block:
             %"res_f" = call float @"f"(i32 %".1", i32 %".2")
@@ -1334,6 +1337,7 @@ my_block:
             %"res_noinline" = call float @"f"(i32 %".1", i32 %".2") noinline
             %"res_alwaysinline" = call float @"f"(i32 %".1", i32 %".2") alwaysinline
             %"res_noinline_ro" = call float @"f"(i32 %".1", i32 %".2") noinline readonly
+            %"res_convergent" = call float @"f"(i32 %".1", i32 %".2") convergent
         """) # noqa E501
 
     def test_call_metadata(self):

llvmlite-0.42.0.dist-info/LICENSE.thirdparty

@@ -0,0 +1,225 @@
+The llvmlite source tree includes code from LLVM that is governed by the
+following license.
+
+==============================================================================
+The Apache License v2.0 with LLVM Exceptions:
+==============================================================================
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+    1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+    2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+    3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+    4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+    5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+    6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+    7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+    8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+    9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+    END OF TERMS AND CONDITIONS
+
+    APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+    Copyright [yyyy] [name of copyright owner]
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+
+---- LLVM Exceptions to the Apache 2.0 License ----
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into an Object form of such source code, you
+may redistribute such embedded portions in such Object form without complying
+with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
+
+In addition, if you combine or link compiled forms of this Software with
+software that is licensed under the GPLv2 ("Combined Software") and if a
+court of competent jurisdiction determines that the patent provision (Section
+3), the indemnity provision (Section 9) or other Section of the License
+conflicts with the conditions of the GPLv2, you may retroactively and
+prospectively choose to deem waived or otherwise exclude such Section(s) of
+the License, but only in their entirety and only with respect to the Combined
+Software.

{llvmlite-0.41.1.dist-info → llvmlite-0.42.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: llvmlite
-Version: 0.41.1
+Version: 0.42.0
 Summary: lightweight wrapper around basic LLVM functionality
 Home-page: http://llvmlite.readthedocs.io
 License: BSD
@@ -10,14 +10,15 @@ Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Compilers
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 License-File: LICENSE
+License-File: LICENSE.thirdparty
 
 ========
 llvmlite
@@ -78,8 +79,8 @@ Key Benefits
 Compatibility
 =============
 
-llvmlite works with Python 3.8 and greater. We attempt to test with the latest
-Python version, this can be checked by looking at the public CI builds.
+llvmlite has been tested with Python 3.9 -- 3.12 and is likely to work with
+greater versions.
 
 As of version 0.41.0, llvmlite requires LLVM 14.x.x on all architectures
 

{llvmlite-0.41.1.dist-info → llvmlite-0.42.0.dist-info}/RECORD

@@ -1,43 +1,45 @@
-llvmlite/_version.py,sha256=fsnaBKvglYPJywrUAvzZsHhvixqEwJIDh0JKz4rwPtw,418
+llvmlite/_version.py,sha256=mrP_SVZnRr17yNMSPH6Pekgh9lG7Rzxay6eRNk2ThxI,418
 llvmlite/utils.py,sha256=BwgrA2JaYaZiHRafshoZBHiYSBskJQMG_K2F2jbW2-w,695
 llvmlite/__init__.py,sha256=PiUSiFLCm0YX5rbHS4xOLGdqdPDC8j3etV3nmEaelzI,92
 llvmlite/tests/refprune_proto.py,sha256=I5g0jWHYlsLCOX3Ct9-fA5_udLfkipzuBAsEkrNsFIk,8677
 llvmlite/tests/customize.py,sha256=85Af1gyZ5rtXXI3qpeTc2DXMrgETjv7hrLN-73A7Fhg,13268
 llvmlite/tests/__main__.py,sha256=10_On1rLj4CX1xsBJ9TbjULvNSp_K0qk9U1N6azUTUw,40
 llvmlite/tests/test_valuerepr.py,sha256=57MaGznJUnqCf0etajnOCoBRue5-nmFTx1bds_5atlE,1989
-llvmlite/tests/test_ir.py,sha256=tAE8Yruj8r1q6c8dk5I-oIJjnSVTADIwWGDKHUVUEo0,105472
-llvmlite/tests/test_binding.py,sha256=Pvz7WxlxK_awXEXDAV30O4zTJ4PWY1-4SWwrRIGKMmA,80827
+llvmlite/tests/test_ir.py,sha256=BdNnJwSzNdG3AsBF_v0xe7MTZMN36NbhrAYSV0mHUQk,105705
+llvmlite/tests/test_binding.py,sha256=ny9nbYoxSvo_b-6ZpwpN7dRU1iWObwqA0FI5mUCk1Kk,86468
 llvmlite/tests/__init__.py,sha256=TBHEOsEq-9M9rF94nES2HxefA-7GYwNE00Y7gTkHrD8,1378
 llvmlite/tests/test_refprune.py,sha256=oyk3HBLCOMPyRG-bj-omO3Ec_1lI66S8iNgZwl81Zs0,14235
-llvmlite/ir/values.py,sha256=5YlGc90Yc7QuzDMcptoXmvfCjcAvhSk4fSnAwF1vSas,33987
+llvmlite/ir/values.py,sha256=XDUlrvVin0gWkDpaXd593S-oXaARbTnLq69bMALRsbI,34001
 llvmlite/ir/_utils.py,sha256=mkpyEMlQ9nHMcWmBMBsJm4S16Y0BfvxBf5brsdMmKio,2001
 llvmlite/ir/transforms.py,sha256=pV79pB20m4N_HLmBEksw5VVP8cxyf7AYGDCbS1E7fOQ,1552
 llvmlite/ir/module.py,sha256=pfpAh-73WMLptKqwgARwZ7aLMHpm88AcJA2GPfGvyVM,9074
 llvmlite/ir/__init__.py,sha256=rNPtrPLshsPJYO4GegWAU-rpbpiYo0xU-CQb3rt0JtE,258
 llvmlite/ir/builder.py,sha256=t6ZCvkwXd1jmb-CGoTW12kLOSTnwjfS_eY9JJs6ij3g,33479
 llvmlite/ir/context.py,sha256=npgEbox0MzChmH7nfHpTdSsN_G4zU-XrpGx5AIYwafk,518
-llvmlite/ir/instructions.py,sha256=UbiK1Ja7JqZuEj0l6sm7-p-zgfu-fXEbhWqrQB43hbw,31753
+llvmlite/ir/instructions.py,sha256=_fpnCyItoGgPJHhcuCrVxwkDEz4O9a_45thxcnBcDuQ,31767
 llvmlite/ir/types.py,sha256=2GX-PIx_jDvt4GIfHkqiEkrJI_gPQqSktOsku2UZTgQ,16149
 llvmlite/binding/object_file.py,sha256=qZMTAi6gcVQq2e3KghHNxVH3Ivzr7zxDPecfiZ1Riy8,2664
 llvmlite/binding/orcjit.py,sha256=HUWDKicxrYK5s2trdrM_KEmkfvwifrP4E9MxmCb8JSM,11856
 llvmlite/binding/common.py,sha256=eCSnnY4sctgeqVwDv9PrH6jpMI45nJPmAz4rfjbPsf8,742
-llvmlite/binding/ffi.py,sha256=bQB6yudHJTlCGaCsnvrhNgWQzJYcvxwvULAo53j3oe4,11950
-llvmlite/binding/executionengine.py,sha256=rJrBP9n0Hm-lo53KRoRssFBLS8XOuIoAp_XWetiesS4,10713
+llvmlite/binding/ffi.py,sha256=sbN4vwClbgpnJHn4-ec2z8gmdCC95_TM3s6kjk6NXp4,12088
+llvmlite/binding/executionengine.py,sha256=PgUFCVJdGvrxXCZAevMv8nUAL8n29Xm58FYO1XYLafc,11022
 llvmlite/binding/transforms.py,sha256=C_Tp0XPV__aOHaVzLLL_QFa-yI9vkDx1gwZADk_KwG8,4947
-llvmlite/binding/libllvmlite.so,sha256=FbHGEraKkuRhDcSfykibfK3umaW4O4eqNYdSxPRuDCA,131449848
+llvmlite/binding/libllvmlite.so,sha256=ioQTw3z8hzpRL9ee1BcYcd2ABqnyGuJbLjNqeyyKk40,131935840
+llvmlite/binding/typeref.py,sha256=T_ZQfvjTdLtARDci2wVuRfnalgEt9Oc2qb7ZUiiTFJ4,5534
 llvmlite/binding/linker.py,sha256=M4bAkoxVAUgxqai5S0_iCHS5EcNRPBX_9zldVqFLV90,489
 llvmlite/binding/analysis.py,sha256=BbCcAAGY0GLAEUek6ZogHkBAmFA9kvpS7333XyIrbhc,2253
 llvmlite/binding/initfini.py,sha256=zF9tJXmCONabkP0d_IqmiU6M_Wn8N8ArkwfXBxf1TDo,1595
 llvmlite/binding/dylib.py,sha256=ypfikOYKiWQZi8h00LhLBXwmPlJ5d86yLOUn01pDjmM,1300
 llvmlite/binding/module.py,sha256=Zf9GcuCEFf1xtOmP-jXqKtJbj4dO8l9a2NEPKTwsimI,11174
-llvmlite/binding/__init__.py,sha256=zjhFN8Ucg5Y_14kwn1OEyiH_X-wEnzwS_WVmkPoSChk,382
-llvmlite/binding/value.py,sha256=21-PwkBgAl26g0sqP2mI_lckSIDvq_LkgoLmzJE_8K4,18845
+llvmlite/binding/__init__.py,sha256=LhAuO8C49hrQ7G2YqcjT8Udkus4ETI1N3zey9Qqt7Jo,405
+llvmlite/binding/value.py,sha256=WGzbTt4bi42WHlOm-wrDkzIpLIV-EYiJU2ExwjeqmfE,18956
 llvmlite/binding/targets.py,sha256=5nxDn73pK_ElQu86EU994Qcd-k5Ja2U127T_oLrW_kk,14802
-llvmlite/binding/passmanagers.py,sha256=zfn-iP-vi5j_1s8JPAnZjPpcahhz1IL98tSdZKCw40s,34412
+llvmlite/binding/passmanagers.py,sha256=EW_DJdG54jOHhaUofowAbar2Rvyi7knV6MRWkox6pTg,34769
 llvmlite/binding/context.py,sha256=l2vdKsJ038PfSKzaU17FCSDYWtByzIFYREmx93JwKW8,657
 llvmlite/binding/options.py,sha256=aDH4SFh6VZ11agtUJO9vAxhVhQkIGAByK9IHKeuRcAI,509
-llvmlite-0.41.1.dist-info/top_level.txt,sha256=WJi8Gq92jA2wv_aV1Oshp9iZ-zMa43Kcmw80kWeGYGA,9
-llvmlite-0.41.1.dist-info/RECORD,,
-llvmlite-0.41.1.dist-info/LICENSE,sha256=S5pyZLAROnsybuhPwkS3OZG1NbSDPkpW1YdQ8qciUNw,1298
-llvmlite-0.41.1.dist-info/METADATA,sha256=ViL9FB2NBHKaVY4Ws8v41nBy-SKPB3-8PJ6HNIW8fTQ,4808
-llvmlite-0.41.1.dist-info/WHEEL,sha256=3zITUdHX-zH-jhKLfklGA9F0ms_hxVHRE4Z-vedBDkY,154
+llvmlite-0.42.0.dist-info/LICENSE.thirdparty,sha256=3FJyk8_C5LTVkELgsgRmcWKEXYVIZRky9anS9K38kos,12561
+llvmlite-0.42.0.dist-info/top_level.txt,sha256=WJi8Gq92jA2wv_aV1Oshp9iZ-zMa43Kcmw80kWeGYGA,9
+llvmlite-0.42.0.dist-info/RECORD,,
+llvmlite-0.42.0.dist-info/LICENSE,sha256=S5pyZLAROnsybuhPwkS3OZG1NbSDPkpW1YdQ8qciUNw,1298
+llvmlite-0.42.0.dist-info/METADATA,sha256=KRN67iICEYpA5na5Vcxr2DeVZA_SbFEyfqllxsNxDNI,4785
+llvmlite-0.42.0.dist-info/WHEEL,sha256=7-IJbjbL0nWUFP_cSrTULDrfI4l8JN0GBqGHPqza7ao,154

{llvmlite-0.41.1.dist-info → llvmlite-0.42.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: false
 Tag: cp310-cp310-manylinux_2_17_aarch64
 Tag: cp310-cp310-manylinux2014_aarch64