llvmlite 0.44.0rc2__cp310-cp310-macosx_10_14_x86_64.whl

llvmlite/binding/module.py

@@ -0,0 +1,349 @@
+from ctypes import (c_char_p, byref, POINTER, c_bool, create_string_buffer,
+                    c_size_t, string_at)
+
+from llvmlite.binding import ffi
+from llvmlite.binding.linker import link_modules
+from llvmlite.binding.common import _decode_string, _encode_string
+from llvmlite.binding.value import ValueRef, TypeRef
+from llvmlite.binding.context import get_global_context
+
+
+def parse_assembly(llvmir, context=None):
+    """
+    Create Module from a LLVM IR string
+    """
+    if context is None:
+        context = get_global_context()
+    llvmir = _encode_string(llvmir)
+    strbuf = c_char_p(llvmir)
+    with ffi.OutputString() as errmsg:
+        mod = ModuleRef(
+            ffi.lib.LLVMPY_ParseAssembly(context, strbuf, errmsg),
+            context)
+        if errmsg:
+            mod.close()
+            raise RuntimeError("LLVM IR parsing error\n{0}".format(errmsg))
+    return mod
+
+
+def parse_bitcode(bitcode, context=None):
+    """
+    Create Module from a LLVM *bitcode* (a bytes object).
+    """
+    if context is None:
+        context = get_global_context()
+    buf = c_char_p(bitcode)
+    bufsize = len(bitcode)
+    with ffi.OutputString() as errmsg:
+        mod = ModuleRef(ffi.lib.LLVMPY_ParseBitcode(
+            context, buf, bufsize, errmsg), context)
+        if errmsg:
+            mod.close()
+            raise RuntimeError(
+                "LLVM bitcode parsing error\n{0}".format(errmsg))
+    return mod
+
+
+class ModuleRef(ffi.ObjectRef):
+    """
+    A reference to a LLVM module.
+    """
+
+    def __init__(self, module_ptr, context):
+        super(ModuleRef, self).__init__(module_ptr)
+        self._context = context
+
+    def __str__(self):
+        with ffi.OutputString() as outstr:
+            ffi.lib.LLVMPY_PrintModuleToString(self, outstr)
+            return str(outstr)
+
+    def as_bitcode(self):
+        """
+        Return the module's LLVM bitcode, as a bytes object.
+        """
+        ptr = c_char_p(None)
+        size = c_size_t(-1)
+        ffi.lib.LLVMPY_WriteBitcodeToString(self, byref(ptr), byref(size))
+        if not ptr:
+            raise MemoryError
+        try:
+            assert size.value >= 0
+            return string_at(ptr, size.value)
+        finally:
+            ffi.lib.LLVMPY_DisposeString(ptr)
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeModule(self)
+
+    def get_function(self, name):
+        """
+        Get a ValueRef pointing to the function named *name*.
+        NameError is raised if the symbol isn't found.
+        """
+        p = ffi.lib.LLVMPY_GetNamedFunction(self, _encode_string(name))
+        if not p:
+            raise NameError(name)
+        return ValueRef(p, 'function', dict(module=self))
+
+    def get_global_variable(self, name):
+        """
+        Get a ValueRef pointing to the global variable named *name*.
+        NameError is raised if the symbol isn't found.
+        """
+        p = ffi.lib.LLVMPY_GetNamedGlobalVariable(self, _encode_string(name))
+        if not p:
+            raise NameError(name)
+        return ValueRef(p, 'global', dict(module=self))
+
+    def get_struct_type(self, name):
+        """
+        Get a TypeRef pointing to a structure type named *name*.
+        NameError is raised if the struct type isn't found.
+        """
+        p = ffi.lib.LLVMPY_GetNamedStructType(self, _encode_string(name))
+        if not p:
+            raise NameError(name)
+        return TypeRef(p)
+
+    def verify(self):
+        """
+        Verify the module IR's correctness.  RuntimeError is raised on error.
+        """
+        with ffi.OutputString() as outmsg:
+            if ffi.lib.LLVMPY_VerifyModule(self, outmsg):
+                raise RuntimeError(str(outmsg))
+
+    @property
+    def name(self):
+        """
+        The module's identifier.
+        """
+        return _decode_string(ffi.lib.LLVMPY_GetModuleName(self))
+
+    @name.setter
+    def name(self, value):
+        ffi.lib.LLVMPY_SetModuleName(self, _encode_string(value))
+
+    @property
+    def source_file(self):
+        """
+        The module's original source file name
+        """
+        return _decode_string(ffi.lib.LLVMPY_GetModuleSourceFileName(self))
+
+    @property
+    def data_layout(self):
+        """
+        This module's data layout specification, as a string.
+        """
+        # LLVMGetDataLayout() points inside a std::string managed by LLVM.
+        with ffi.OutputString(owned=False) as outmsg:
+            ffi.lib.LLVMPY_GetDataLayout(self, outmsg)
+            return str(outmsg)
+
+    @data_layout.setter
+    def data_layout(self, strrep):
+        ffi.lib.LLVMPY_SetDataLayout(self,
+                                     create_string_buffer(
+                                         strrep.encode('utf8')))
+
+    @property
+    def triple(self):
+        """
+        This module's target "triple" specification, as a string.
+        """
+        # LLVMGetTarget() points inside a std::string managed by LLVM.
+        with ffi.OutputString(owned=False) as outmsg:
+            ffi.lib.LLVMPY_GetTarget(self, outmsg)
+            return str(outmsg)
+
+    @triple.setter
+    def triple(self, strrep):
+        ffi.lib.LLVMPY_SetTarget(self,
+                                 create_string_buffer(
+                                     strrep.encode('utf8')))
+
+    def link_in(self, other, preserve=False):
+        """
+        Link the *other* module into this one.  The *other* module will
+        be destroyed unless *preserve* is true.
+        """
+        if preserve:
+            other = other.clone()
+        link_modules(self, other)
+
+    @property
+    def global_variables(self):
+        """
+        Return an iterator over this module's global variables.
+        The iterator will yield a ValueRef for each global variable.
+
+        Note that global variables don't include functions
+        (a function is a "global value" but not a "global variable" in
+         LLVM parlance)
+        """
+        it = ffi.lib.LLVMPY_ModuleGlobalsIter(self)
+        return _GlobalsIterator(it, dict(module=self))
+
+    @property
+    def functions(self):
+        """
+        Return an iterator over this module's functions.
+        The iterator will yield a ValueRef for each function.
+        """
+        it = ffi.lib.LLVMPY_ModuleFunctionsIter(self)
+        return _FunctionsIterator(it, dict(module=self))
+
+    @property
+    def struct_types(self):
+        """
+        Return an iterator over the struct types defined in
+        the module. The iterator will yield a TypeRef.
+        """
+        it = ffi.lib.LLVMPY_ModuleTypesIter(self)
+        return _TypesIterator(it, dict(module=self))
+
+    def clone(self):
+        return ModuleRef(ffi.lib.LLVMPY_CloneModule(self), self._context)
+
+
+class _Iterator(ffi.ObjectRef):
+
+    kind = None
+
+    def __init__(self, ptr, parents):
+        ffi.ObjectRef.__init__(self, ptr)
+        self._parents = parents
+        assert self.kind is not None
+
+    def __next__(self):
+        vp = self._next()
+        if vp:
+            return ValueRef(vp, self.kind, self._parents)
+        else:
+            raise StopIteration
+
+    next = __next__
+
+    def __iter__(self):
+        return self
+
+
+class _GlobalsIterator(_Iterator):
+
+    kind = 'global'
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeGlobalsIter(self)
+
+    def _next(self):
+        return ffi.lib.LLVMPY_GlobalsIterNext(self)
+
+
+class _FunctionsIterator(_Iterator):
+
+    kind = 'function'
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeFunctionsIter(self)
+
+    def _next(self):
+        return ffi.lib.LLVMPY_FunctionsIterNext(self)
+
+
+class _TypesIterator(_Iterator):
+
+    kind = 'type'
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeTypesIter(self)
+
+    def __next__(self):
+        vp = self._next()
+        if vp:
+            return TypeRef(vp)
+        else:
+            raise StopIteration
+
+    def _next(self):
+        return ffi.lib.LLVMPY_TypesIterNext(self)
+
+    next = __next__
+
+
+# =============================================================================
+# Set function FFI
+
+ffi.lib.LLVMPY_ParseAssembly.argtypes = [ffi.LLVMContextRef,
+                                         c_char_p,
+                                         POINTER(c_char_p)]
+ffi.lib.LLVMPY_ParseAssembly.restype = ffi.LLVMModuleRef
+
+ffi.lib.LLVMPY_ParseBitcode.argtypes = [ffi.LLVMContextRef,
+                                        c_char_p, c_size_t,
+                                        POINTER(c_char_p)]
+ffi.lib.LLVMPY_ParseBitcode.restype = ffi.LLVMModuleRef
+
+ffi.lib.LLVMPY_DisposeModule.argtypes = [ffi.LLVMModuleRef]
+
+ffi.lib.LLVMPY_PrintModuleToString.argtypes = [ffi.LLVMModuleRef,
+                                               POINTER(c_char_p)]
+ffi.lib.LLVMPY_WriteBitcodeToString.argtypes = [ffi.LLVMModuleRef,
+                                                POINTER(c_char_p),
+                                                POINTER(c_size_t)]
+
+ffi.lib.LLVMPY_GetNamedFunction.argtypes = [ffi.LLVMModuleRef,
+                                            c_char_p]
+ffi.lib.LLVMPY_GetNamedFunction.restype = ffi.LLVMValueRef
+
+ffi.lib.LLVMPY_VerifyModule.argtypes = [ffi.LLVMModuleRef,
+                                        POINTER(c_char_p)]
+ffi.lib.LLVMPY_VerifyModule.restype = c_bool
+
+ffi.lib.LLVMPY_GetDataLayout.argtypes = [ffi.LLVMModuleRef, POINTER(c_char_p)]
+ffi.lib.LLVMPY_SetDataLayout.argtypes = [ffi.LLVMModuleRef, c_char_p]
+
+ffi.lib.LLVMPY_GetTarget.argtypes = [ffi.LLVMModuleRef, POINTER(c_char_p)]
+ffi.lib.LLVMPY_SetTarget.argtypes = [ffi.LLVMModuleRef, c_char_p]
+
+ffi.lib.LLVMPY_GetNamedGlobalVariable.argtypes = [ffi.LLVMModuleRef, c_char_p]
+ffi.lib.LLVMPY_GetNamedGlobalVariable.restype = ffi.LLVMValueRef
+
+ffi.lib.LLVMPY_GetNamedStructType.argtypes = [ffi.LLVMModuleRef, c_char_p]
+ffi.lib.LLVMPY_GetNamedStructType.restype = ffi.LLVMTypeRef
+
+ffi.lib.LLVMPY_ModuleGlobalsIter.argtypes = [ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_ModuleGlobalsIter.restype = ffi.LLVMGlobalsIterator
+
+ffi.lib.LLVMPY_DisposeGlobalsIter.argtypes = [ffi.LLVMGlobalsIterator]
+
+ffi.lib.LLVMPY_GlobalsIterNext.argtypes = [ffi.LLVMGlobalsIterator]
+ffi.lib.LLVMPY_GlobalsIterNext.restype = ffi.LLVMValueRef
+
+ffi.lib.LLVMPY_ModuleFunctionsIter.argtypes = [ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_ModuleFunctionsIter.restype = ffi.LLVMFunctionsIterator
+
+ffi.lib.LLVMPY_ModuleTypesIter.argtypes = [ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_ModuleTypesIter.restype = ffi.LLVMTypesIterator
+
+ffi.lib.LLVMPY_DisposeFunctionsIter.argtypes = [ffi.LLVMFunctionsIterator]
+
+ffi.lib.LLVMPY_DisposeTypesIter.argtypes = [ffi.LLVMTypesIterator]
+
+ffi.lib.LLVMPY_FunctionsIterNext.argtypes = [ffi.LLVMFunctionsIterator]
+ffi.lib.LLVMPY_FunctionsIterNext.restype = ffi.LLVMValueRef
+
+ffi.lib.LLVMPY_TypesIterNext.argtypes = [ffi.LLVMTypesIterator]
+ffi.lib.LLVMPY_TypesIterNext.restype = ffi.LLVMTypeRef
+
+ffi.lib.LLVMPY_CloneModule.argtypes = [ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_CloneModule.restype = ffi.LLVMModuleRef
+
+ffi.lib.LLVMPY_GetModuleName.argtypes = [ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_GetModuleName.restype = c_char_p
+
+ffi.lib.LLVMPY_SetModuleName.argtypes = [ffi.LLVMModuleRef, c_char_p]
+
+ffi.lib.LLVMPY_GetModuleSourceFileName.argtypes = [ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_GetModuleSourceFileName.restype = c_char_p

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]