llvmlite 0.44.0rc2__cp310-cp310-win_amd64.whl → 0.45.0__cp310-cp310-win_amd64.whl

llvmlite/__init__.py

@@ -2,9 +2,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():
+# 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_OPAQUE_POINTERS', '0') == '1'
-opaque_pointers_enabled = _opaque_pointers_enabled()
-del _opaque_pointers_enabled
+  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

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

llvmlite/binding/__init__.py

@@ -8,12 +8,11 @@ from .linker import *
 from .module import *
 from .options import *
 from .newpassmanagers import *
-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 *
 from .orcjit import *
+from .config import *

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

@@ -1,18 +1,14 @@
 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(opaque_pointers_enabled))
+        ffi.lib.LLVMPY_ContextCreate())
 
 
 def get_global_context():
     return GlobalContextRef(
-        ffi.lib.LLVMPY_GetGlobalContext(opaque_pointers_enabled))
+        ffi.lib.LLVMPY_GetGlobalContext())
 
 
 class ContextRef(ffi.ObjectRef):
@@ -28,12 +24,8 @@ 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

@@ -40,7 +40,7 @@ LLVMObjectFileRef = _make_opaque_ref("LLVMObjectFile")
 LLVMSectionIteratorRef = _make_opaque_ref("LLVMSectionIterator")
 LLVMOrcLLJITRef = _make_opaque_ref("LLVMOrcLLJITRef")
 LLVMOrcDylibTrackerRef = _make_opaque_ref("LLVMOrcDylibTrackerRef")
-
+LLVMTimePassesHandlerRef = _make_opaque_ref("LLVMTimePassesHandler")
 LLVMPipelineTuningOptionsRef = _make_opaque_ref("LLVMPipeLineTuningOptions")
 LLVMModulePassManagerRef = _make_opaque_ref("LLVMModulePassManager")
 LLVMFunctionPassManagerRef = _make_opaque_ref("LLVMFunctionPassManager")

llvmlite/binding/initfini.py

@@ -5,9 +5,21 @@ from llvmlite.binding import ffi
 
 def initialize():
     """
-    Initialize the LLVM core.
+    Initialize the LLVM core (deprecated).
+
+    This function is deprecated and will raise an error when called.
+    LLVM initialization is now handled automatically and no longer
+    requires explicit initialization calls.
+
+    Raises:
+        RuntimeError: Always raised as this function is no longer needed.
     """
-    ffi.lib.LLVMPY_InitializeCore()
+    raise RuntimeError(
+        "llvmlite.binding.initialize() is deprecated and will be removed. "
+        "LLVM initialization is now handled automatically. "
+        "Please remove calls to this function from your code and check for "
+        "other behavioral changes that may have occurred due to LLVM updates."
+    )
 
 
 def initialize_all_targets():