llvmlite 0.44.0rc2__cp313-cp313-macosx_11_0_arm64.whl → 0.45.0rc1__cp313-cp313-macosx_11_0_arm64.whl

llvmlite/binding/targets.py

@@ -7,9 +7,9 @@ from llvmlite.binding.initfini import llvm_version_info
 from llvmlite.binding.common import _decode_string, _encode_string
 from collections import namedtuple
 
-# FIXME: Remove `opaque_pointers_enabled` once typed pointers are no longer
-# supported.
-from llvmlite import opaque_pointers_enabled
+# import for backward compatible API, `has_svml` is now in config module.
+from llvmlite.binding.config import _has_svml as has_svml  # noqa: F401
+
 
 Triple = namedtuple('Triple', ['Arch', 'SubArch', 'Vendor',
                                'OS', 'Env', 'ObjectFormat'])
@@ -119,28 +119,17 @@ def get_host_cpu_name():
 llvm_version_major = llvm_version_info[0]
 
 
-if llvm_version_major >= 15:
-    _object_formats = {
-        0: "Unknown",
-        1: "COFF",
-        2: "DXContainer",
-        3: "ELF",
-        4: "GOFF",
-        5: "MachO",
-        6: "SPIRV",
-        7: "Wasm",
-        8: "XCOFF",
-    }
-else:
-    _object_formats = {
-        0: "Unknown",
-        1: "COFF",
-        2: "ELF",
-        3: "GOFF",
-        4: "MachO",
-        5: "Wasm",
-        6: "XCOFF",
-    }
+_object_formats = {
+    0: "Unknown",
+    1: "COFF",
+    2: "DXContainer",
+    3: "ELF",
+    4: "GOFF",
+    5: "MachO",
+    6: "SPIRV",
+    7: "Wasm",
+    8: "XCOFF",
+}
 
 
 def get_object_format(triple=None):
@@ -202,30 +191,6 @@ class TargetData(ffi.ObjectRef):
         """
         return ffi.lib.LLVMPY_ABIAlignmentOfType(self, ty)
 
-    def get_pointee_abi_size(self, ty):
-        """
-        Get ABI size of pointee type of LLVM pointer type *ty*.
-        """
-        if opaque_pointers_enabled:
-            raise RuntimeError("Cannot get pointee type in opaque pointer "
-                               "mode.")
-        size = ffi.lib.LLVMPY_ABISizeOfElementType(self, ty)
-        if size == -1:
-            raise RuntimeError("Not a pointer type: %s" % (ty,))
-        return size
-
-    def get_pointee_abi_alignment(self, ty):
-        """
-        Get minimum ABI alignment of pointee type of LLVM pointer type *ty*.
-        """
-        if opaque_pointers_enabled:
-            raise RuntimeError("Cannot get pointee type in opaque pointer "
-                               "mode.")
-        size = ffi.lib.LLVMPY_ABIAlignmentOfElementType(self, ty)
-        if size == -1:
-            raise RuntimeError("Not a pointer type: %s" % (ty,))
-        return size
-
 
 RELOC = frozenset(['default', 'static', 'pic', 'dynamicnopic'])
 CODEMODEL = frozenset(['default', 'jitdefault', 'small', 'kernel', 'medium',
@@ -387,16 +352,6 @@ class TargetMachine(ffi.ObjectRef):
             return str(out)
 
 
-def has_svml():
-    """
-    Returns True if SVML was enabled at FFI support compile time.
-    """
-    if ffi.lib.LLVMPY_HasSVMLSupport() == 0:
-        return False
-    else:
-        return True
-
-
 # ============================================================================
 # FFI
 
@@ -440,16 +395,6 @@ ffi.lib.LLVMPY_ABIAlignmentOfType.argtypes = [ffi.LLVMTargetDataRef,
                                               ffi.LLVMTypeRef]
 ffi.lib.LLVMPY_ABIAlignmentOfType.restype = c_longlong
 
-# FIXME: Remove me once typed pointers are no longer supported.
-ffi.lib.LLVMPY_ABISizeOfElementType.argtypes = [ffi.LLVMTargetDataRef,
-                                                ffi.LLVMTypeRef]
-ffi.lib.LLVMPY_ABISizeOfElementType.restype = c_longlong
-
-# FIXME: Remove me once typed pointers are no longer supported.
-ffi.lib.LLVMPY_ABIAlignmentOfElementType.argtypes = [ffi.LLVMTargetDataRef,
-                                                     ffi.LLVMTypeRef]
-ffi.lib.LLVMPY_ABIAlignmentOfElementType.restype = c_longlong
-
 ffi.lib.LLVMPY_GetTargetFromTriple.argtypes = [c_char_p, POINTER(c_char_p)]
 ffi.lib.LLVMPY_GetTargetFromTriple.restype = ffi.LLVMTargetRef
 
@@ -515,6 +460,3 @@ ffi.lib.LLVMPY_CreateTargetMachineData.argtypes = [
     ffi.LLVMTargetMachineRef,
 ]
 ffi.lib.LLVMPY_CreateTargetMachineData.restype = ffi.LLVMTargetDataRef
-
-ffi.lib.LLVMPY_HasSVMLSupport.argtypes = []
-ffi.lib.LLVMPY_HasSVMLSupport.restype = c_int

llvmlite/binding/typeref.py

@@ -4,9 +4,6 @@ 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
@@ -108,21 +105,10 @@ class TypeRef(ffi.ObjectRef):
         """
         Returns iterator over enclosing types
         """
-        if self.is_pointer and opaque_pointers_enabled:
+        if self.is_pointer:
             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):
-        """
-        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):
         """
@@ -226,10 +212,6 @@ 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
-
 ffi.lib.LLVMPY_TypeIsPointer.argtypes = [ffi.LLVMTypeRef]
 ffi.lib.LLVMPY_TypeIsPointer.restype = c_bool
 

llvmlite/ir/module.py

@@ -42,6 +42,15 @@ class Module(object):
             fixed_ops.append((name, op))
         return fixed_ops
 
+    def str_ditok_operands(self, operands):
+        str_ops = []
+        for name, op in operands:
+            if name == 'encoding' and isinstance(op, values.DIToken):
+                # use string value instead of address of object
+                op = op.value
+            str_ops.append((name, op))
+        return str_ops
+
     def add_metadata(self, operands):
         """
         Add an unnamed metadata to the module with the given *operands*
@@ -73,7 +82,8 @@ class Module(object):
         an instruction.
         """
         operands = tuple(sorted(self._fix_di_operands(operands.items())))
-        key = (kind, operands, is_distinct)
+        str_op_key = tuple(sorted(self.str_ditok_operands(operands)))
+        key = (kind, str_op_key, is_distinct)
         if key not in self._metadatacache:
             n = len(self.metadata)
             di = values.DIValue(self, is_distinct, kind, operands, name=str(n))

llvmlite/ir/types.py

@@ -4,11 +4,9 @@ Classes that are LLVM types
 
 import struct
 
+from llvmlite import ir_layer_typed_pointers_enabled
 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'))
@@ -137,16 +135,22 @@ class PointerType(Type):
         else:
             return "ptr"
 
+    def __eq__(self, other):
+        return (isinstance(other, PointerType) and
+                self.addrspace == other.addrspace)
+
     def __hash__(self):
         return hash(PointerType)
 
+    @property
+    def intrinsic_name(self):
+        return 'p%d' % self.addrspace
+
     @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()
 
 
@@ -163,7 +167,7 @@ class _TypedPointerType(PointerType):
         self.is_opaque = False
 
     def _to_string(self):
-        if not opaque_pointers_enabled:
+        if ir_layer_typed_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()
@@ -173,7 +177,8 @@ class _TypedPointerType(PointerType):
         if isinstance(other, _TypedPointerType):
             return (self.pointee, self.addrspace) == (other.pointee,
                                                       other.addrspace)
-        return isinstance(other, PointerType)
+        return (isinstance(other, PointerType) and
+                self.addrspace == other.addrspace)
 
     def __hash__(self):
         return hash(_TypedPointerType)
@@ -188,18 +193,9 @@ class _TypedPointerType(PointerType):
 
     @property
     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))
+        if ir_layer_typed_pointers_enabled:
+            return 'p%d%s' % (self.addrspace, self.pointee.intrinsic_name)
+        return super(_TypedPointerType, self).intrinsic_name
 
 
 class VoidType(Type):

llvmlite/tests/refprune_proto.py

@@ -103,6 +103,7 @@ def case7():
 
 def case8():
     edges = {
+        "entry:": ["A"],
         "A": ["B", "C"],
         "B": ["C"],
         "C": [],