llvmlite 0.46.0b1__cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl

llvmlite/__init__.py

@@ -0,0 +1,11 @@
+from ._version import get_versions
+__version__ = get_versions()['version']
+del get_versions
+
+# We default to IR layer typed pointers being enabled, since they're needed in
+# the most common usage scenarios with later LLVMs.
+def _ir_layer_typed_pointers_enabled():
+  import os
+  return os.environ.get('LLVMLITE_ENABLE_IR_LAYER_TYPED_POINTERS', '1') == '1'
+ir_layer_typed_pointers_enabled = _ir_layer_typed_pointers_enabled()
+del _ir_layer_typed_pointers_enabled

llvmlite/_version.py

@@ -0,0 +1,11 @@
+
+# This file was generated by 'versioneer.py' (0.14) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+version_version = '0.46.0b1'
+version_full = '5f77715902a7a311953fad682f41f25c81c21790'
+def get_versions(default={}, verbose=False):
+    return {'version': version_version, 'full': version_full}
+

llvmlite/binding/__init__.py

@@ -0,0 +1,18 @@
+"""
+Things that rely on the LLVM library
+"""
+from .dylib import *
+from .executionengine import *
+from .initfini import *
+from .linker import *
+from .module import *
+from .options import *
+from .newpassmanagers import *
+from .targets import *
+from .value import *
+from .typeref import *
+from .analysis import *
+from .object_file import *
+from .context import *
+from .orcjit import *
+from .config import *

llvmlite/binding/analysis.py

@@ -0,0 +1,69 @@
+"""
+A collection of analysis utilities
+"""
+
+from ctypes import POINTER, c_char_p, c_int
+
+from llvmlite.binding import ffi
+from llvmlite.binding.module import parse_assembly
+
+
+def get_function_cfg(func, show_inst=True):
+    """Return a string of the control-flow graph of the function in DOT
+    format. If the input `func` is not a materialized function, the module
+    containing the function is parsed to create an actual LLVM module.
+    The `show_inst` flag controls whether the instructions of each block
+    are printed.
+    """
+    assert func is not None
+    from llvmlite import ir
+    if isinstance(func, ir.Function):
+        mod = parse_assembly(str(func.module))
+        func = mod.get_function(func.name)
+
+    # Assume func is a materialized function
+    with ffi.OutputString() as dotstr:
+        ffi.lib.LLVMPY_WriteCFG(func, dotstr, show_inst)
+        return str(dotstr)
+
+
+def view_dot_graph(graph, filename=None, view=False):
+    """
+    View the given DOT source.  If view is True, the image is rendered
+    and viewed by the default application in the system.  The file path of
+    the output is returned.  If view is False, a graphviz.Source object is
+    returned.  If view is False and the environment is in a IPython session,
+    an IPython image object is returned and can be displayed inline in the
+    notebook.
+
+    This function requires the graphviz package.
+
+    Args
+    ----
+    - graph [str]: a DOT source code
+    - filename [str]: optional.  if given and view is True, this specifies
+                      the file path for the rendered output to write to.
+    - view [bool]: if True, opens the rendered output file.
+
+    """
+    # Optionally depends on graphviz package
+    import graphviz as gv
+
+    src = gv.Source(graph)
+    if view:
+        # Returns the output file path
+        return src.render(filename, view=view)
+    else:
+        # Attempts to show the graph in IPython notebook
+        try:
+            __IPYTHON__
+        except NameError:
+            return src
+        else:
+            import IPython.display as display
+            format = 'svg'
+            return display.SVG(data=src.pipe(format))
+
+
+# Ctypes binding
+ffi.lib.LLVMPY_WriteCFG.argtypes = [ffi.LLVMValueRef, POINTER(c_char_p), c_int]

llvmlite/binding/common.py

@@ -0,0 +1,34 @@
+import atexit
+
+
+def _encode_string(s):
+    encoded = s.encode('utf-8')
+    return encoded
+
+
+def _decode_string(b):
+    return b.decode('utf-8')
+
+
+_encode_string.__doc__ = """Encode a string for use by LLVM."""
+_decode_string.__doc__ = """Decode a LLVM character (byte)string."""
+
+
+_shutting_down = [False]
+
+
+def _at_shutdown():
+    _shutting_down[0] = True
+
+
+atexit.register(_at_shutdown)
+
+
+def _is_shutting_down(_shutting_down=_shutting_down):
+    """
+    Whether the interpreter is currently shutting down.
+    For use in finalizers, __del__ methods, and similar; it is advised
+    to early bind this function rather than look it up when calling it,
+    since at shutdown module globals may be cleared.
+    """
+    return _shutting_down[0]

llvmlite/binding/config.py

@@ -0,0 +1,143 @@
+import os
+import warnings
+from functools import cache
+from ctypes import c_int, c_char_p
+from llvmlite.binding import ffi
+
+# these are here as they cannot be lazy bound as the module globals make calls
+# to the LLVMPY API functions
+ffi.lib.LLVMPY_HasSVMLSupport.argtypes = ()
+ffi.lib.LLVMPY_HasSVMLSupport.restype = c_int
+
+ffi.lib.LLVMPY_IsStaticLibstdcxxLinkageBuild.argtypes = ()
+ffi.lib.LLVMPY_IsStaticLibstdcxxLinkageBuild.restype = c_int
+
+ffi.lib.LLVMPY_IsDynamicLLVMLinkageBuild.argtypes = ()
+ffi.lib.LLVMPY_IsDynamicLLVMLinkageBuild.restype = c_int
+
+ffi.lib.LLVMPY_PackageFormat.argtypes = ()
+ffi.lib.LLVMPY_PackageFormat.restype = c_char_p
+
+ffi.lib.LLVMPY_LlvmAssertionsState.argtypes = ()
+ffi.lib.LLVMPY_LlvmAssertionsState.restype = c_char_p
+
+
+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
+
+
+has_svml = _has_svml()
+
+
+def _build_llvm_linkage_type():
+    """
+    Returns "static" if the FFI support is statically linked against LLVM,
+    returns "dynamic" otherwise.
+    """
+    if ffi.lib.LLVMPY_IsDynamicLLVMLinkageBuild() == 0:
+        return "static"
+    else:
+        return "dynamic"
+
+
+build_llvm_linkage_type = _build_llvm_linkage_type()
+
+
+def _build_libstdcxx_linkage_type():
+    """
+    Returns "static" if the FFI support is statically linked against libstdc++,
+    returns "dynamic" otherwise.
+    """
+    if ffi.lib.LLVMPY_IsStaticLibstdcxxLinkageBuild() == 1:
+        return "static"
+    else:
+        return "dynamic"
+
+
+build_libstdcxx_linkage_type = _build_libstdcxx_linkage_type()
+
+
+def _package_format():
+    """
+    Returns "wheel", "conda" or "unspecified"
+    """
+    return ffi.lib.LLVMPY_PackageFormat().decode()
+
+
+package_format = _package_format()
+
+
+def _llvm_assertions_state():
+    """
+    Returns one of "on", "off" or "unknown". Depending on whether it is
+    determined that LLVM was build with assertions on, off, or is not known.
+    "Is not known" is typically from a dynamic linkage against LLVM in which
+    case it's not easily identified whether LLVM was built with assertions.
+    """
+    return ffi.lib.LLVMPY_LlvmAssertionsState().decode()
+
+
+llvm_assertions_state = _llvm_assertions_state()
+
+
+@cache
+def get_sysinfo():
+    d = dict()
+    d["ffi_lib_location"] = ffi.lib._name
+    d["package_format"] = package_format
+    d["llvm_linkage_type"] = build_llvm_linkage_type
+    d["libstdcxx_linkage_type"] = build_libstdcxx_linkage_type
+    d["llvm_assertions_state"] = llvm_assertions_state
+
+    # import lief
+    HAVE_LIEF = False
+    try:
+        import lief
+        HAVE_LIEF = True
+    except ImportError:
+        msg = "py-lief package not found, sysinfo is limited as a result"
+        warnings.warn(msg)
+
+    d["lief_probe_status"] = HAVE_LIEF
+    d["linked_libraries"] = None
+    d["canonicalised_linked_libraries"] = None
+
+    def canonicalise_library_type(dso):
+        """Canonicalises the representation of the binary::libraries as a
+        sequence of strings"""
+        # Note lief v16:
+        # Mach-O .libraries are DylibCommand instances.
+        # Windows PE and Linux ELF .libraries are strings.
+        return [getattr(x, "name", x) for x in dso.libraries]
+
+    def canonicalise_library_spelling(libs):
+        # This adjusts the library "spelling" so that it just contains the
+        # name given to the linker. e.g. `@rpath/somewhere/libfoo.so.1.3`
+        # would be canonicalised to "foo".
+        fixes = []
+        for lib in libs:
+            # some libraries, e.g. Mach-O have an @rpath or system path
+            # prefix in their name, remove it.
+            path_stripped = os.path.split(lib)[-1]
+            # Assume all library names contain at least one dot, even if they
+            # don't it's fine, the first part is the piece of interest.
+            prefix_libname = path_stripped.split(".")[0]
+            linker_name = prefix_libname.replace("lib", "").replace("LIB", "")
+            # further canonicalize by referring to all libraries in lower case.
+            fixes.append(linker_name.lower())
+        return fixes
+
+    if HAVE_LIEF:
+        dso = lief.parse(d["ffi_lib_location"])
+        link_libs = tuple(canonicalise_library_type(dso))
+        d["linked_libraries"] = link_libs
+        canonicalised_libs = canonicalise_library_spelling(link_libs)
+        d["canonicalised_linked_libraries"] = canonicalised_libs
+
+    return d

llvmlite/binding/context.py

@@ -0,0 +1,31 @@
+from llvmlite.binding import ffi
+
+
+def create_context():
+    return ContextRef(
+        ffi.lib.LLVMPY_ContextCreate())
+
+
+def get_global_context():
+    return GlobalContextRef(
+        ffi.lib.LLVMPY_GetGlobalContext())
+
+
+class ContextRef(ffi.ObjectRef):
+    def __init__(self, context_ptr):
+        super(ContextRef, self).__init__(context_ptr)
+
+    def _dispose(self):
+        ffi.lib.LLVMPY_ContextDispose(self)
+
+
+class GlobalContextRef(ContextRef):
+    def _dispose(self):
+        pass
+
+
+ffi.lib.LLVMPY_GetGlobalContext.restype = ffi.LLVMContextRef
+
+ffi.lib.LLVMPY_ContextCreate.restype = ffi.LLVMContextRef
+
+ffi.lib.LLVMPY_ContextDispose.argtypes = [ffi.LLVMContextRef]

llvmlite/binding/dylib.py

@@ -0,0 +1,45 @@
+from ctypes import c_void_p, c_char_p, c_bool, POINTER
+
+from llvmlite.binding import ffi
+from llvmlite.binding.common import _encode_string
+
+
+def address_of_symbol(name):
+    """
+    Get the in-process address of symbol named *name*.
+    An integer is returned, or None if the symbol isn't found.
+    """
+    return ffi.lib.LLVMPY_SearchAddressOfSymbol(_encode_string(name))
+
+
+def add_symbol(name, address):
+    """
+    Register the *address* of global symbol *name*.  This will make
+    it usable (e.g. callable) from LLVM-compiled functions.
+    """
+    ffi.lib.LLVMPY_AddSymbol(_encode_string(name), c_void_p(address))
+
+
+def load_library_permanently(filename):
+    """
+    Load an external library
+    """
+    with ffi.OutputString() as outerr:
+        if ffi.lib.LLVMPY_LoadLibraryPermanently(
+                _encode_string(filename), outerr):
+            raise RuntimeError(str(outerr))
+
+# ============================================================================
+# FFI
+
+
+ffi.lib.LLVMPY_AddSymbol.argtypes = [
+    c_char_p,
+    c_void_p,
+]
+
+ffi.lib.LLVMPY_SearchAddressOfSymbol.argtypes = [c_char_p]
+ffi.lib.LLVMPY_SearchAddressOfSymbol.restype = c_void_p
+
+ffi.lib.LLVMPY_LoadLibraryPermanently.argtypes = [c_char_p, POINTER(c_char_p)]
+ffi.lib.LLVMPY_LoadLibraryPermanently.restype = c_bool

llvmlite/binding/executionengine.py

@@ -0,0 +1,330 @@
+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)
+
+from llvmlite.binding import ffi, targets, object_file
+
+
+# Just check these weren't optimized out of the DLL.
+ffi.lib.LLVMPY_LinkInMCJIT
+
+
+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, use_lmm, outerr)
+        if not engine:
+            raise RuntimeError(str(outerr))
+
+    target_machine._owned = True
+    return ExecutionEngine(engine, module=module)
+
+
+def check_jit_execution():
+    """
+    Check the system allows execution of in-memory JITted functions.
+    An exception is raised otherwise.
+    """
+    errno = ffi.lib.LLVMPY_TryAllocateExecutableMemory()
+    if errno != 0:
+        raise OSError(errno,
+                      "cannot allocate executable memory. "
+                      "This may be due to security restrictions on your "
+                      "system, such as SELinux or similar mechanisms."
+                      )
+
+
+class ExecutionEngine(ffi.ObjectRef):
+    """An ExecutionEngine owns all Modules associated with it.
+    Deleting the engine will remove all associated modules.
+    It is an error to delete the associated modules.
+    """
+    _object_cache = None
+
+    def __init__(self, ptr, module):
+        """
+        Module ownership is transferred to the EE
+        """
+        self._modules = set([module])
+        self._td = None
+        module._owned = True
+        ffi.ObjectRef.__init__(self, ptr)
+
+    def get_function_address(self, name):
+        """
+        Return the address of the function named *name* as an integer.
+
+        It's a fatal error in LLVM if the symbol of *name* doesn't exist.
+        """
+        return ffi.lib.LLVMPY_GetFunctionAddress(self, name.encode("ascii"))
+
+    def get_global_value_address(self, name):
+        """
+        Return the address of the global value named *name* as an integer.
+
+        It's a fatal error in LLVM if the symbol of *name* doesn't exist.
+        """
+        return ffi.lib.LLVMPY_GetGlobalValueAddress(self, name.encode("ascii"))
+
+    def add_global_mapping(self, gv, addr):
+        ffi.lib.LLVMPY_AddGlobalMapping(self, gv, addr)
+
+    def add_module(self, module):
+        """
+        Ownership of module is transferred to the execution engine
+        """
+        if module in self._modules:
+            raise KeyError("module already added to this engine")
+        ffi.lib.LLVMPY_AddModule(self, module)
+        module._owned = True
+        self._modules.add(module)
+
+    def finalize_object(self):
+        """
+        Make sure all modules owned by the execution engine are fully processed
+        and "usable" for execution.
+        """
+        ffi.lib.LLVMPY_FinalizeObject(self)
+
+    def run_static_constructors(self):
+        """
+        Run static constructors which initialize module-level static objects.
+        """
+        ffi.lib.LLVMPY_RunStaticConstructors(self)
+
+    def run_static_destructors(self):
+        """
+        Run static destructors which perform module-level cleanup of static
+        resources.
+        """
+        ffi.lib.LLVMPY_RunStaticDestructors(self)
+
+    def remove_module(self, module):
+        """
+        Ownership of module is returned
+        """
+        with ffi.OutputString() as outerr:
+            if ffi.lib.LLVMPY_RemoveModule(self, module, outerr):
+                raise RuntimeError(str(outerr))
+        self._modules.remove(module)
+        module._owned = False
+
+    @property
+    def target_data(self):
+        """
+        The TargetData for this execution engine.
+        """
+        if self._td is not None:
+            return self._td
+        ptr = ffi.lib.LLVMPY_GetExecutionEngineTargetData(self)
+        self._td = targets.TargetData(ptr)
+        self._td._owned = True
+        return self._td
+
+    def enable_jit_events(self):
+        """
+        Enable JIT events for profiling of generated code.
+        Return value indicates whether connection to profiling tool
+        was successful.
+        """
+        ret = ffi.lib.LLVMPY_EnableJITEvents(self)
+        return ret
+
+    def _find_module_ptr(self, module_ptr):
+        """
+        Find the ModuleRef corresponding to the given pointer.
+        """
+        ptr = cast(module_ptr, c_void_p).value
+        for module in self._modules:
+            if cast(module._ptr, c_void_p).value == ptr:
+                return module
+        return None
+
+    def add_object_file(self, obj_file):
+        """
+        Add object file to the jit. object_file can be instance of
+        :class:ObjectFile or a string representing file system path
+        """
+        if isinstance(obj_file, str):
+            obj_file = object_file.ObjectFileRef.from_path(obj_file)
+
+        ffi.lib.LLVMPY_MCJITAddObjectFile(self, obj_file)
+
+    def set_object_cache(self, notify_func=None, getbuffer_func=None):
+        """
+        Set the object cache "notifyObjectCompiled" and "getBuffer"
+        callbacks to the given Python functions.
+        """
+        self._object_cache_notify = notify_func
+        self._object_cache_getbuffer = getbuffer_func
+        # Lifetime of the object cache is managed by us.
+        self._object_cache = _ObjectCacheRef(self)
+        # Note this doesn't keep a reference to self, to avoid reference
+        # cycles.
+        ffi.lib.LLVMPY_SetObjectCache(self, self._object_cache)
+
+    def _raw_object_cache_notify(self, data):
+        """
+        Low-level notify hook.
+        """
+        if self._object_cache_notify is None:
+            return
+        module_ptr = data.contents.module_ptr
+        buf_ptr = data.contents.buf_ptr
+        buf_len = data.contents.buf_len
+        buf = string_at(buf_ptr, buf_len)
+        module = self._find_module_ptr(module_ptr)
+        if module is None:
+            # The LLVM EE should only give notifications for modules
+            # known by us.
+            raise RuntimeError("object compilation notification "
+                               "for unknown module %s" % (module_ptr,))
+        self._object_cache_notify(module, buf)
+
+    def _raw_object_cache_getbuffer(self, data):
+        """
+        Low-level getbuffer hook.
+        """
+        if self._object_cache_getbuffer is None:
+            return
+        module_ptr = data.contents.module_ptr
+        module = self._find_module_ptr(module_ptr)
+        if module is None:
+            # The LLVM EE should only give notifications for modules
+            # known by us.
+            raise RuntimeError("object compilation notification "
+                               "for unknown module %s" % (module_ptr,))
+
+        buf = self._object_cache_getbuffer(module)
+        if buf is not None:
+            # Create a copy, which will be freed by the caller
+            data[0].buf_ptr = ffi.lib.LLVMPY_CreateByteString(buf, len(buf))
+            data[0].buf_len = len(buf)
+
+    def _dispose(self):
+        # The modules will be cleaned up by the EE
+        for mod in self._modules:
+            mod.detach()
+        if self._td is not None:
+            self._td.detach()
+        self._modules.clear()
+        self._object_cache = None
+        self._capi.LLVMPY_DisposeExecutionEngine(self)
+
+
+class _ObjectCacheRef(ffi.ObjectRef):
+    """
+    Internal: an ObjectCache instance for use within an ExecutionEngine.
+    """
+
+    def __init__(self, obj):
+        ptr = ffi.lib.LLVMPY_CreateObjectCache(_notify_c_hook,
+                                               _getbuffer_c_hook,
+                                               obj)
+        ffi.ObjectRef.__init__(self, ptr)
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeObjectCache(self)
+
+
+# ============================================================================
+# FFI
+
+
+ffi.lib.LLVMPY_CreateMCJITCompiler.argtypes = [
+    ffi.LLVMModuleRef,
+    ffi.LLVMTargetMachineRef,
+    c_bool,
+    POINTER(c_char_p),
+]
+ffi.lib.LLVMPY_CreateMCJITCompiler.restype = ffi.LLVMExecutionEngineRef
+
+ffi.lib.LLVMPY_RemoveModule.argtypes = [
+    ffi.LLVMExecutionEngineRef,
+    ffi.LLVMModuleRef,
+    POINTER(c_char_p),
+]
+ffi.lib.LLVMPY_RemoveModule.restype = c_bool
+
+ffi.lib.LLVMPY_AddModule.argtypes = [
+    ffi.LLVMExecutionEngineRef,
+    ffi.LLVMModuleRef
+]
+
+ffi.lib.LLVMPY_AddGlobalMapping.argtypes = [ffi.LLVMExecutionEngineRef,
+                                            ffi.LLVMValueRef,
+                                            c_void_p]
+
+ffi.lib.LLVMPY_FinalizeObject.argtypes = [ffi.LLVMExecutionEngineRef]
+
+ffi.lib.LLVMPY_GetExecutionEngineTargetData.argtypes = [
+    ffi.LLVMExecutionEngineRef
+]
+ffi.lib.LLVMPY_GetExecutionEngineTargetData.restype = ffi.LLVMTargetDataRef
+
+ffi.lib.LLVMPY_TryAllocateExecutableMemory.argtypes = []
+ffi.lib.LLVMPY_TryAllocateExecutableMemory.restype = c_int
+
+ffi.lib.LLVMPY_GetFunctionAddress.argtypes = [
+    ffi.LLVMExecutionEngineRef,
+    c_char_p
+]
+ffi.lib.LLVMPY_GetFunctionAddress.restype = c_uint64
+
+ffi.lib.LLVMPY_GetGlobalValueAddress.argtypes = [
+    ffi.LLVMExecutionEngineRef,
+    c_char_p
+]
+ffi.lib.LLVMPY_GetGlobalValueAddress.restype = c_uint64
+
+ffi.lib.LLVMPY_MCJITAddObjectFile.argtypes = [
+    ffi.LLVMExecutionEngineRef,
+    ffi.LLVMObjectFileRef
+]
+
+
+class _ObjectCacheData(Structure):
+    _fields_ = [
+        ('module_ptr', ffi.LLVMModuleRef),
+        ('buf_ptr', c_void_p),
+        ('buf_len', c_size_t),
+    ]
+
+
+_ObjectCacheNotifyFunc = CFUNCTYPE(None, py_object,
+                                   POINTER(_ObjectCacheData))
+_ObjectCacheGetBufferFunc = CFUNCTYPE(None, py_object,
+                                      POINTER(_ObjectCacheData))
+
+# XXX The ctypes function wrappers are created at the top-level, otherwise
+# there are issues when creating CFUNCTYPEs in child processes on CentOS 5
+# 32 bits.
+_notify_c_hook = _ObjectCacheNotifyFunc(
+    ExecutionEngine._raw_object_cache_notify)
+_getbuffer_c_hook = _ObjectCacheGetBufferFunc(
+    ExecutionEngine._raw_object_cache_getbuffer)
+
+ffi.lib.LLVMPY_CreateObjectCache.argtypes = [_ObjectCacheNotifyFunc,
+                                             _ObjectCacheGetBufferFunc,
+                                             py_object]
+ffi.lib.LLVMPY_CreateObjectCache.restype = ffi.LLVMObjectCacheRef
+
+ffi.lib.LLVMPY_DisposeObjectCache.argtypes = [ffi.LLVMObjectCacheRef]
+
+ffi.lib.LLVMPY_SetObjectCache.argtypes = [ffi.LLVMExecutionEngineRef,
+                                          ffi.LLVMObjectCacheRef]
+
+ffi.lib.LLVMPY_CreateByteString.restype = c_void_p
+ffi.lib.LLVMPY_CreateByteString.argtypes = [c_void_p, c_size_t]