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

llvmlite/__init__.py

@@ -1,3 +1,10 @@
 from ._version import get_versions
 __version__ = get_versions()['version']
 del get_versions
+
+# FIXME: Remove me once typed pointers are no longer supported.
+def _opaque_pointers_enabled():
+  import os
+  return os.environ.get('LLVMLITE_ENABLE_OPAQUE_POINTERS', '0') == '1'
+opaque_pointers_enabled = _opaque_pointers_enabled()
+del _opaque_pointers_enabled

llvmlite/_version.py

@@ -4,8 +4,8 @@
 # unpacked source archive. Distribution tarballs contain a pre-generated copy
 # of this file.
 
-version_version = '0.43.0rc1'
-version_full = '4868420e431184249a2db85a1ad88a60c88b7e51'
+version_version = '0.44.0rc2'
+version_full = '8213a18880cfe34a54b684aea555975bfe6f110b'
 def get_versions(default={}, verbose=False):
     return {'version': version_version, 'full': version_full}
 

llvmlite/binding/__init__.py

@@ -7,6 +7,7 @@ from .initfini import *
 from .linker import *
 from .module import *
 from .options import *
+from .newpassmanagers import *
 from .passmanagers import *
 from .targets import *
 from .transforms import *

llvmlite/binding/context.py

@@ -1,12 +1,18 @@
 from llvmlite.binding import ffi
 
+# FIXME: Remove me once typed pointers are no longer supported.
+from llvmlite import opaque_pointers_enabled
+from ctypes import c_bool
+
 
 def create_context():
-    return ContextRef(ffi.lib.LLVMPY_ContextCreate())
+    return ContextRef(
+        ffi.lib.LLVMPY_ContextCreate(opaque_pointers_enabled))
 
 
 def get_global_context():
-    return GlobalContextRef(ffi.lib.LLVMPY_GetGlobalContext())
+    return GlobalContextRef(
+        ffi.lib.LLVMPY_GetGlobalContext(opaque_pointers_enabled))
 
 
 class ContextRef(ffi.ObjectRef):
@@ -22,8 +28,12 @@ class GlobalContextRef(ContextRef):
         pass
 
 
+# FIXME: Remove argtypes once typed pointers are no longer supported.
+ffi.lib.LLVMPY_GetGlobalContext.argtypes = [c_bool]
 ffi.lib.LLVMPY_GetGlobalContext.restype = ffi.LLVMContextRef
 
+# FIXME: Remove argtypes once typed pointers are no longer supported.
+ffi.lib.LLVMPY_ContextCreate.argtypes = [c_bool]
 ffi.lib.LLVMPY_ContextCreate.restype = ffi.LLVMContextRef
 
 ffi.lib.LLVMPY_ContextDispose.argtypes = [ffi.LLVMContextRef]

llvmlite/binding/ffi.py

@@ -41,6 +41,11 @@ LLVMSectionIteratorRef = _make_opaque_ref("LLVMSectionIterator")
 LLVMOrcLLJITRef = _make_opaque_ref("LLVMOrcLLJITRef")
 LLVMOrcDylibTrackerRef = _make_opaque_ref("LLVMOrcDylibTrackerRef")
 
+LLVMPipelineTuningOptionsRef = _make_opaque_ref("LLVMPipeLineTuningOptions")
+LLVMModulePassManagerRef = _make_opaque_ref("LLVMModulePassManager")
+LLVMFunctionPassManagerRef = _make_opaque_ref("LLVMFunctionPassManager")
+LLVMPassBuilderRef = _make_opaque_ref("LLVMPassBuilder")
+
 
 class _LLVMLock:
     """A Lock to guarantee thread-safety for the LLVM C-API.
@@ -207,7 +212,7 @@ def _importlib_resources_path_repl(package, resource):
 
 
 _importlib_resources_path = (_importlib_resources_path_repl
-                             if sys.version_info[:2] >= (3, 9)
+                             if sys.version_info[:2] >= (3, 10)
                              else _impres.path)
 
 

llvmlite/binding/newpassmanagers.py

@@ -0,0 +1,357 @@
+from ctypes import c_bool, c_int, c_size_t
+from enum import IntFlag
+from llvmlite.binding import ffi
+
+
+def create_new_module_pass_manager():
+    return ModulePassManager()
+
+
+def create_new_function_pass_manager():
+    return FunctionPassManager()
+
+
+def create_pass_builder(tm, pto):
+    return PassBuilder(tm, pto)
+
+
+def create_pipeline_tuning_options(speed_level=2, size_level=0):
+    return PipelineTuningOptions(speed_level, size_level)
+
+
+class RefPruneSubpasses(IntFlag):
+    PER_BB       = 0b0001    # noqa: E221
+    DIAMOND      = 0b0010    # noqa: E221
+    FANOUT       = 0b0100    # noqa: E221
+    FANOUT_RAISE = 0b1000
+    ALL = PER_BB | DIAMOND | FANOUT | FANOUT_RAISE
+
+
+class ModulePassManager(ffi.ObjectRef):
+
+    def __init__(self, ptr=None):
+        if ptr is None:
+            ptr = ffi.lib.LLVMPY_CreateNewModulePassManager()
+        super().__init__(ptr)
+
+    def run(self, module, pb):
+        ffi.lib.LLVMPY_RunNewModulePassManager(self, module, pb)
+
+    def add_verifier(self):
+        ffi.lib.LLVMPY_AddVerifierPass(self)
+
+    def add_aa_eval_pass(self):
+        ffi.lib.LLVMPY_AddAAEvalPass_module(self)
+
+    def add_simplify_cfg_pass(self):
+        ffi.lib.LLVMPY_AddSimplifyCFGPass_module(self)
+
+    def add_loop_unroll_pass(self):
+        ffi.lib.LLVMPY_AddLoopUnrollPass_module(self)
+
+    def add_loop_rotate_pass(self):
+        ffi.lib.LLVMPY_AddLoopRotatePass_module(self)
+
+    def add_instruction_combine_pass(self):
+        ffi.lib.LLVMPY_AddInstructionCombinePass_module(self)
+
+    def add_jump_threading_pass(self, threshold=-1):
+        ffi.lib.LLVMPY_AddJumpThreadingPass_module(self, threshold)
+
+    def _dispose(self):
+        ffi.lib.LLVMPY_DisposeNewModulePassManger(self)
+
+    # Non-standard LLVM passes
+    def add_refprune_pass(self, subpasses_flags=RefPruneSubpasses.ALL,
+                          subgraph_limit=1000):
+        """Add Numba specific Reference count pruning pass.
+
+        Parameters
+        ----------
+        subpasses_flags : RefPruneSubpasses
+            A bitmask to control the subpasses to be enabled.
+        subgraph_limit : int
+            Limit the fanout pruners to working on a subgraph no bigger than
+            this number of basic-blocks to avoid spending too much time in very
+            large graphs. Default is 1000. Subject to change in future
+            versions.
+        """
+        iflags = RefPruneSubpasses(subpasses_flags)
+        ffi.lib.LLVMPY_AddRefPrunePass_module(self, iflags, subgraph_limit)
+
+
+class FunctionPassManager(ffi.ObjectRef):
+
+    def __init__(self, ptr=None):
+        if ptr is None:
+            ptr = ffi.lib.LLVMPY_CreateNewFunctionPassManager()
+        super().__init__(ptr)
+
+    def run(self, fun, pb):
+        ffi.lib.LLVMPY_RunNewFunctionPassManager(self, fun, pb)
+
+    def add_aa_eval_pass(self):
+        ffi.lib.LLVMPY_AddAAEvalPass_function(self)
+
+    def add_simplify_cfg_pass(self):
+        ffi.lib.LLVMPY_AddSimplifyCFGPass_function(self)
+
+    def add_loop_unroll_pass(self):
+        ffi.lib.LLVMPY_AddLoopUnrollPass_function(self)
+
+    def add_loop_rotate_pass(self):
+        ffi.lib.LLVMPY_AddLoopRotatePass_function(self)
+
+    def add_instruction_combine_pass(self):
+        ffi.lib.LLVMPY_AddInstructionCombinePass_function(self)
+
+    def add_jump_threading_pass(self, threshold=-1):
+        ffi.lib.LLVMPY_AddJumpThreadingPass_function(self, threshold)
+
+    def _dispose(self):
+        ffi.lib.LLVMPY_DisposeNewFunctionPassManger(self)
+
+    # Non-standard LLVM passes
+    def add_refprune_pass(self, subpasses_flags=RefPruneSubpasses.ALL,
+                          subgraph_limit=1000):
+        """Add Numba specific Reference count pruning pass.
+
+        Parameters
+        ----------
+        subpasses_flags : RefPruneSubpasses
+            A bitmask to control the subpasses to be enabled.
+        subgraph_limit : int
+            Limit the fanout pruners to working on a subgraph no bigger than
+            this number of basic-blocks to avoid spending too much time in very
+            large graphs. Default is 1000. Subject to change in future
+            versions.
+        """
+        iflags = RefPruneSubpasses(subpasses_flags)
+        ffi.lib.LLVMPY_AddRefPrunePass_function(self, iflags, subgraph_limit)
+
+
+class PipelineTuningOptions(ffi.ObjectRef):
+
+    def __init__(self, speed_level=2, size_level=0):
+        self._speed_level = None
+        self._size_level = None
+        self.speed_level = speed_level
+        self.size_level = size_level
+        super().__init__(ffi.lib.LLVMPY_CreatePipelineTuningOptions())
+
+    @property
+    def speed_level(self):
+        return self._speed_level
+
+    @speed_level.setter
+    def speed_level(self, value):
+        if not 0 <= value <= 3:
+            raise ValueError(
+                "Optimization level for speed should be 0, 1, 2, or 3")
+        self._speed_level = value
+
+    @property
+    def size_level(self):
+        return self._size_level
+
+    @size_level.setter
+    def size_level(self, value):
+        if not 0 <= value <= 2:
+            raise ValueError("Optimization level for size should be 0, 1, or 2")
+        if value != 0 and self.speed_level != 2:
+            raise ValueError(
+                "Optimization for size should be encoded with speed level == 2")
+        self._size_level = value
+
+    @property
+    def loop_interleaving(self):
+        return ffi.lib.LLVMPY_PTOGetLoopInterleaving(self)
+
+    @loop_interleaving.setter
+    def loop_interleaving(self, value):
+        ffi.lib.LLVMPY_PTOSetLoopInterleaving(self, value)
+
+    @property
+    def loop_vectorization(self):
+        return ffi.lib.LLVMPY_PTOGetLoopVectorization(self)
+
+    @loop_vectorization.setter
+    def loop_vectorization(self, value):
+        ffi.lib.LLVMPY_PTOSetLoopVectorization(self, value)
+
+    @property
+    def slp_vectorization(self):
+        return ffi.lib.LLVMPY_PTOGetSLPVectorization(self)
+
+    @slp_vectorization.setter
+    def slp_vectorization(self, value):
+        ffi.lib.LLVMPY_PTOSetSLPVectorization(self, value)
+
+    @property
+    def loop_unrolling(self):
+        return ffi.lib.LLVMPY_PTOGetLoopUnrolling(self)
+
+    @loop_unrolling.setter
+    def loop_unrolling(self, value):
+        ffi.lib.LLVMPY_PTOSetLoopUnrolling(self, value)
+
+    # // FIXME: Available from llvm16
+    # @property
+    # def inlining_threshold(self):
+    #     return ffi.lib.LLVMPY_PTOGetInlinerThreshold(self)
+
+    # @inlining_threshold.setter
+    # def inlining_threshold(self, value):
+    #     ffi.lib.LLVMPY_PTOSetInlinerThreshold(self, value)
+
+    def _dispose(self):
+        ffi.lib.LLVMPY_DisposePipelineTuningOptions(self)
+
+
+class PassBuilder(ffi.ObjectRef):
+
+    def __init__(self, tm, pto):
+        super().__init__(ffi.lib.LLVMPY_CreatePassBuilder(tm, pto))
+        self._pto = pto
+        self._tm = tm
+
+    def getModulePassManager(self):
+        return ModulePassManager(
+            ffi.lib.LLVMPY_buildPerModuleDefaultPipeline(
+                self, self._pto.speed_level, self._pto.size_level)
+        )
+
+    def getFunctionPassManager(self):
+        return FunctionPassManager(
+            ffi.lib.LLVMPY_buildFunctionSimplificationPipeline(
+                self, self._pto.speed_level, self._pto.size_level)
+        )
+
+    def _dispose(self):
+        ffi.lib.LLVMPY_DisposePassBuilder(self)
+
+
+# ============================================================================
+# FFI
+
+# ModulePassManager
+
+ffi.lib.LLVMPY_CreateNewModulePassManager.restype = ffi.LLVMModulePassManagerRef
+
+ffi.lib.LLVMPY_RunNewModulePassManager.argtypes = [
+    ffi.LLVMModulePassManagerRef, ffi.LLVMModuleRef,
+    ffi.LLVMPassBuilderRef,]
+
+ffi.lib.LLVMPY_AddVerifierPass.argtypes = [ffi.LLVMModulePassManagerRef,]
+ffi.lib.LLVMPY_AddAAEvalPass_module.argtypes = [ffi.LLVMModulePassManagerRef,]
+ffi.lib.LLVMPY_AddSimplifyCFGPass_module.argtypes = [
+    ffi.LLVMModulePassManagerRef,]
+
+ffi.lib.LLVMPY_AddLoopUnrollPass_module.argtypes = [
+    ffi.LLVMModulePassManagerRef,]
+
+ffi.lib.LLVMPY_AddLoopRotatePass_module.argtypes = [
+    ffi.LLVMModulePassManagerRef,]
+
+ffi.lib.LLVMPY_AddInstructionCombinePass_module.argtypes = [
+    ffi.LLVMModulePassManagerRef,]
+
+ffi.lib.LLVMPY_AddJumpThreadingPass_module.argtypes = [
+    ffi.LLVMModulePassManagerRef,]
+
+ffi.lib.LLVMPY_DisposeNewModulePassManger.argtypes = [
+    ffi.LLVMModulePassManagerRef,]
+
+ffi.lib.LLVMPY_AddRefPrunePass_module.argtypes = [
+    ffi.LLVMModulePassManagerRef, c_int, c_size_t,
+]
+
+# FunctionPassManager
+
+ffi.lib.LLVMPY_CreateNewFunctionPassManager.restype = \
+    ffi.LLVMFunctionPassManagerRef
+
+ffi.lib.LLVMPY_RunNewFunctionPassManager.argtypes = [
+    ffi.LLVMFunctionPassManagerRef, ffi.LLVMValueRef,
+    ffi.LLVMPassBuilderRef,]
+
+ffi.lib.LLVMPY_AddAAEvalPass_function.argtypes = [
+    ffi.LLVMFunctionPassManagerRef,]
+
+ffi.lib.LLVMPY_AddSimplifyCFGPass_function.argtypes = [
+    ffi.LLVMFunctionPassManagerRef,]
+
+ffi.lib.LLVMPY_AddLoopUnrollPass_function.argtypes = [
+    ffi.LLVMFunctionPassManagerRef,]
+
+ffi.lib.LLVMPY_AddLoopRotatePass_function.argtypes = [
+    ffi.LLVMFunctionPassManagerRef,]
+
+ffi.lib.LLVMPY_AddInstructionCombinePass_function.argtypes = [
+    ffi.LLVMFunctionPassManagerRef,]
+
+ffi.lib.LLVMPY_AddJumpThreadingPass_function.argtypes = [
+    ffi.LLVMFunctionPassManagerRef, c_int,]
+
+ffi.lib.LLVMPY_DisposeNewFunctionPassManger.argtypes = [
+    ffi.LLVMFunctionPassManagerRef,]
+
+ffi.lib.LLVMPY_AddRefPrunePass_function.argtypes = [
+    ffi.LLVMFunctionPassManagerRef, c_int, c_size_t,
+]
+
+# PipelineTuningOptions
+
+ffi.lib.LLVMPY_CreatePipelineTuningOptions.restype = \
+    ffi.LLVMPipelineTuningOptionsRef
+
+ffi.lib.LLVMPY_PTOGetLoopInterleaving.restype = c_bool
+ffi.lib.LLVMPY_PTOGetLoopInterleaving.argtypes = [
+    ffi.LLVMPipelineTuningOptionsRef,]
+
+ffi.lib.LLVMPY_PTOSetLoopInterleaving.argtypes = [
+    ffi.LLVMPipelineTuningOptionsRef, c_bool]
+
+ffi.lib.LLVMPY_PTOGetLoopVectorization.restype = c_bool
+ffi.lib.LLVMPY_PTOGetLoopVectorization.argtypes = [
+    ffi.LLVMPipelineTuningOptionsRef,]
+
+ffi.lib.LLVMPY_PTOSetLoopVectorization.argtypes = [
+    ffi.LLVMPipelineTuningOptionsRef, c_bool]
+
+ffi.lib.LLVMPY_PTOGetSLPVectorization.restype = c_bool
+ffi.lib.LLVMPY_PTOGetSLPVectorization.argtypes = [
+    ffi.LLVMPipelineTuningOptionsRef,]
+
+ffi.lib.LLVMPY_PTOSetSLPVectorization.argtypes = [
+    ffi.LLVMPipelineTuningOptionsRef, c_bool]
+
+ffi.lib.LLVMPY_PTOGetLoopUnrolling.restype = c_bool
+ffi.lib.LLVMPY_PTOGetLoopUnrolling.argtypes = [
+    ffi.LLVMPipelineTuningOptionsRef,]
+
+ffi.lib.LLVMPY_PTOSetLoopUnrolling.argtypes = [
+    ffi.LLVMPipelineTuningOptionsRef, c_bool]
+
+ffi.lib.LLVMPY_DisposePipelineTuningOptions.argtypes = \
+    [ffi.LLVMPipelineTuningOptionsRef,]
+
+# PassBuilder
+
+ffi.lib.LLVMPY_CreatePassBuilder.restype = ffi.LLVMPassBuilderRef
+ffi.lib.LLVMPY_CreatePassBuilder.argtypes = [ffi.LLVMTargetMachineRef,
+                                             ffi.LLVMPipelineTuningOptionsRef,]
+
+ffi.lib.LLVMPY_DisposePassBuilder.argtypes = [ffi.LLVMPassBuilderRef,]
+
+# Pipeline builders
+
+ffi.lib.LLVMPY_buildPerModuleDefaultPipeline.restype = \
+    ffi.LLVMModulePassManagerRef
+ffi.lib.LLVMPY_buildPerModuleDefaultPipeline.argtypes = [
+    ffi.LLVMPassBuilderRef, c_int, c_int]
+
+ffi.lib.LLVMPY_buildFunctionSimplificationPipeline.restype = \
+    ffi.LLVMFunctionPassManagerRef
+ffi.lib.LLVMPY_buildFunctionSimplificationPipeline.argtypes = [
+    ffi.LLVMPassBuilderRef, c_int, c_int]

llvmlite/binding/passmanagers.py

@@ -1,4 +1,4 @@
-from ctypes import (c_bool, c_char_p, c_int, c_size_t, c_uint, Structure, byref,
+from ctypes import (c_bool, c_char_p, c_int, c_size_t, Structure, byref,
                     POINTER)
 from collections import namedtuple
 from enum import IntFlag
@@ -8,11 +8,11 @@ import os
 from tempfile import mkstemp
 from llvmlite.binding.common import _encode_string
 
+llvm_version_major = llvm_version_info[0]
+
 _prunestats = namedtuple('PruneStats',
                          ('basicblock diamond fanout fanout_raise'))
 
-llvm_version_major = llvm_version_info[0]
-
 
 class PruneStats(_prunestats):
     """ Holds statistics from reference count pruning.
@@ -261,9 +261,7 @@ class PassManager(ffi.ObjectRef):
 
         LLVM 14: `llvm::createArgumentPromotionPass`
         """  # noqa E501
-        if llvm_version_major > 14:
-            raise RuntimeError('ArgumentPromotionPass unavailable in LLVM > 14')
-        ffi.lib.LLVMPY_AddArgPromotionPass(self, max_elements)
+        raise RuntimeError('ArgumentPromotionPass unavailable in LLVM > 14')
 
     def add_break_critical_edges_pass(self):
         """
@@ -342,6 +340,10 @@ class PassManager(ffi.ObjectRef):
 
         LLVM 14: `llvm::createAggressiveInstCombinerPass`
         """  # noqa E501
+        if llvm_version_major > 15:
+            msg = "AggressiveInstrCombinerPass unavailable in LLVM > 15"
+            raise RuntimeError(msg)
+
         ffi.lib.LLVMPY_AddAggressiveInstructionCombiningPass(self)
 
     def add_internalize_pass(self):
@@ -538,6 +540,8 @@ class PassManager(ffi.ObjectRef):
 
         LLVM 14: `llvm::createPruneEHPass`
         """  # noqa E501
+        if llvm_version_major > 15:
+            raise RuntimeError("PruneEHPass unavailable in LLVM > 15")
         ffi.lib.LLVMPY_AddPruneExceptionHandlingPass(self)
 
     def add_reassociate_expressions_pass(self):
@@ -638,7 +642,7 @@ class PassManager(ffi.ObjectRef):
 
     def add_loop_rotate_pass(self):
         """http://llvm.org/docs/Passes.html#loop-rotate-rotate-loops."""
-        ffi.lib.LLVMPY_LLVMAddLoopRotatePass(self)
+        ffi.lib.LLVMPY_AddLoopRotatePass(self)
 
     def add_target_library_info(self, triple):
         ffi.lib.LLVMPY_AddTargetLibraryInfoPass(self, _encode_string(triple))
@@ -668,7 +672,7 @@ class PassManager(ffi.ObjectRef):
             versions.
         """
         iflags = RefPruneSubpasses(subpasses_flags)
-        ffi.lib.LLVMPY_AddRefPrunePass(self, iflags, subgraph_limit)
+        ffi.lib.LLVMPY_AddLegacyRefPrunePass(self, iflags, subgraph_limit)
 
 
 class ModulePassManager(PassManager):
@@ -871,18 +875,16 @@ ffi.lib.LLVMPY_AddRegionInfoPass.argtypes = [ffi.LLVMPassManagerRef]
 ffi.lib.LLVMPY_AddScalarEvolutionAAPass.argtypes = [ffi.LLVMPassManagerRef]
 ffi.lib.LLVMPY_AddAggressiveDCEPass.argtypes = [ffi.LLVMPassManagerRef]
 ffi.lib.LLVMPY_AddAlwaysInlinerPass.argtypes = [ffi.LLVMPassManagerRef, c_bool]
-
-if llvm_version_major < 15:
-    ffi.lib.LLVMPY_AddArgPromotionPass.argtypes = [
-        ffi.LLVMPassManagerRef, c_uint]
-
 ffi.lib.LLVMPY_AddBreakCriticalEdgesPass.argtypes = [ffi.LLVMPassManagerRef]
 ffi.lib.LLVMPY_AddDeadStoreEliminationPass.argtypes = [
     ffi.LLVMPassManagerRef]
 ffi.lib.LLVMPY_AddReversePostOrderFunctionAttrsPass.argtypes = [
     ffi.LLVMPassManagerRef]
-ffi.lib.LLVMPY_AddAggressiveInstructionCombiningPass.argtypes = [
-    ffi.LLVMPassManagerRef]
+
+if llvm_version_major < 16:
+    ffi.lib.LLVMPY_AddAggressiveInstructionCombiningPass.argtypes = [
+        ffi.LLVMPassManagerRef]
+
 ffi.lib.LLVMPY_AddInternalizePass.argtypes = [ffi.LLVMPassManagerRef]
 ffi.lib.LLVMPY_AddLCSSAPass.argtypes = [ffi.LLVMPassManagerRef]
 ffi.lib.LLVMPY_AddLoopDeletionPass.argtypes = [ffi.LLVMPassManagerRef]
@@ -901,7 +903,12 @@ ffi.lib.LLVMPY_AddMemCpyOptimizationPass.argtypes = [ffi.LLVMPassManagerRef]
 ffi.lib.LLVMPY_AddMergeFunctionsPass.argtypes = [ffi.LLVMPassManagerRef]
 ffi.lib.LLVMPY_AddMergeReturnsPass.argtypes = [ffi.LLVMPassManagerRef]
 ffi.lib.LLVMPY_AddPartialInliningPass.argtypes = [ffi.LLVMPassManagerRef]
-ffi.lib.LLVMPY_AddPruneExceptionHandlingPass.argtypes = [ffi.LLVMPassManagerRef]
+
+if llvm_version_major < 16:
+    ffi.lib.LLVMPY_AddPruneExceptionHandlingPass.argtypes = [
+        ffi.LLVMPassManagerRef
+    ]
+
 ffi.lib.LLVMPY_AddReassociatePass.argtypes = [ffi.LLVMPassManagerRef]
 ffi.lib.LLVMPY_AddDemoteRegisterToMemoryPass.argtypes = [ffi.LLVMPassManagerRef]
 ffi.lib.LLVMPY_AddSinkPass.argtypes = [ffi.LLVMPassManagerRef]
@@ -933,7 +940,7 @@ 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]
+ffi.lib.LLVMPY_AddLegacyRefPrunePass.argtypes = [ffi.LLVMPassManagerRef, c_int,
+                                                 c_size_t]
 
 ffi.lib.LLVMPY_DumpRefPruneStats.argtypes = [POINTER(_c_PruneStats), c_bool]

llvmlite/binding/targets.py

@@ -3,7 +3,16 @@ from ctypes import (POINTER, c_char_p, c_longlong, c_int, c_size_t,
                     c_void_p, string_at)
 
 from llvmlite.binding import ffi
+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
+
+Triple = namedtuple('Triple', ['Arch', 'SubArch', 'Vendor',
+                               'OS', 'Env', 'ObjectFormat'])
 
 
 def get_process_triple():
@@ -18,6 +27,25 @@ def get_process_triple():
         return str(out)
 
 
+def get_triple_parts(triple: str):
+    """
+    Return a tuple of the parts of the given triple.
+    """
+    with ffi.OutputString() as arch, \
+            ffi.OutputString() as vendor, \
+            ffi.OutputString() as os, ffi.OutputString() as env:
+        ffi.lib.LLVMPY_GetTripleParts(triple.encode('utf8'),
+                                      arch, vendor, os, env)
+        arch = str(arch)
+        subarch = ''
+        for _str in triple.split('-'):
+            if _str.startswith(arch):
+                subarch = _str[len(arch):]
+                break
+        return Triple(arch, subarch, str(vendor), str(os),
+                      str(env), get_object_format(triple))
+
+
 class FeatureMap(dict):
     """
     Maps feature name to a boolean indicating the availability of the feature.
@@ -87,11 +115,32 @@ def get_host_cpu_name():
         return str(out)
 
 
-_object_formats = {
-    1: "COFF",
-    2: "ELF",
-    3: "MachO",
-}
+# Adapted from https://github.com/llvm/llvm-project/blob/release/15.x/llvm/include/llvm/ADT/Triple.h#L269 # noqa
+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",
+    }
 
 
 def get_object_format(triple=None):
@@ -147,10 +196,19 @@ class TargetData(ffi.ObjectRef):
                              "type?".format(position, str(ty)))
         return offset
 
+    def get_abi_alignment(self, ty):
+        """
+        Get minimum ABI alignment of LLVM type *ty*.
+        """
+        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,))
@@ -160,6 +218,9 @@ class TargetData(ffi.ObjectRef):
         """
         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,))
@@ -340,6 +401,9 @@ def has_svml():
 # FFI
 
 ffi.lib.LLVMPY_GetProcessTriple.argtypes = [POINTER(c_char_p)]
+ffi.lib.LLVMPY_GetTripleParts.argtypes = [c_char_p, POINTER(c_char_p),
+                                          POINTER(c_char_p), POINTER(c_char_p),
+                                          POINTER(c_char_p)]
 
 ffi.lib.LLVMPY_GetHostCPUFeatures.argtypes = [POINTER(c_char_p)]
 ffi.lib.LLVMPY_GetHostCPUFeatures.restype = c_int
@@ -372,10 +436,16 @@ ffi.lib.LLVMPY_OffsetOfElement.argtypes = [ffi.LLVMTargetDataRef,
                                            c_int]
 ffi.lib.LLVMPY_OffsetOfElement.restype = c_longlong
 
+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