llvmlite 0.43.0rc1__tar.gz → 0.44.0rc2__tar.gz

{llvmlite-0.43.0rc1 → llvmlite-0.44.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: llvmlite
-Version: 0.43.0rc1
+Version: 0.44.0rc2
 Summary: lightweight wrapper around basic LLVM functionality
 Home-page: http://llvmlite.readthedocs.io
 License: BSD
@@ -10,13 +10,13 @@ Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Compilers
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 License-File: LICENSE
 License-File: LICENSE.thirdparty
 
@@ -79,17 +79,18 @@ Key Benefits
 Compatibility
 =============
 
-llvmlite has been tested with Python 3.9 -- 3.12 and is likely to work with
+llvmlite has been tested with Python 3.10 -- 3.13 and is likely to work with
 greater versions.
 
-As of version 0.41.0, llvmlite requires LLVM 14.x.x on all architectures
+As of version 0.44.0, llvmlite requires LLVM 15.x.x on all architectures
 
 Historical compatibility table:
 
 =================  ========================
 llvmlite versions  compatible LLVM versions
 =================  ========================
-0.41.0 - ...       14.x.x
+0.44.0 - ......    15.x.x
+0.41.0 - 0.43.0    14.x.x
 0.40.0 - 0.40.1    11.x.x and 14.x.x (12.x.x and 13.x.x untested but may work)
 0.37.0 - 0.39.1    11.x.x
 0.34.0 - 0.36.0    10.0.x (9.0.x for  ``aarch64`` only)

{llvmlite-0.43.0rc1 → llvmlite-0.44.0rc2}/README.rst

@@ -57,17 +57,18 @@ Key Benefits
 Compatibility
 =============
 
-llvmlite has been tested with Python 3.9 -- 3.12 and is likely to work with
+llvmlite has been tested with Python 3.10 -- 3.13 and is likely to work with
 greater versions.
 
-As of version 0.41.0, llvmlite requires LLVM 14.x.x on all architectures
+As of version 0.44.0, llvmlite requires LLVM 15.x.x on all architectures
 
 Historical compatibility table:
 
 =================  ========================
 llvmlite versions  compatible LLVM versions
 =================  ========================
-0.41.0 - ...       14.x.x
+0.44.0 - ......    15.x.x
+0.41.0 - 0.43.0    14.x.x
 0.40.0 - 0.40.1    11.x.x and 14.x.x (12.x.x and 13.x.x untested but may work)
 0.37.0 - 0.39.1    11.x.x
 0.34.0 - 0.36.0    10.0.x (9.0.x for  ``aarch64`` only)

llvmlite-0.44.0rc2/examples/npm_passes.py

@@ -0,0 +1,73 @@
+"""
+This example demonstrates how to use the new module pass manager to optimize a
+module using the loop unrolling and CFG simplification passes.
+"""
+
+import faulthandler
+import llvmlite.binding as llvm
+
+# Dump Python traceback in the event of a segfault
+faulthandler.enable()
+
+# All are required to initialize LLVM
+llvm.initialize()
+llvm.initialize_native_target()
+llvm.initialize_native_asmprinter()
+
+# Module to optimize
+strmod = """
+define i32 @foo3(i32* noalias nocapture readonly %src) {
+entry:
+  br label %loop.header
+
+loop.header:
+  %iv = phi i64 [ 0, %entry ], [ %inc, %loop.latch ]
+  %r1  = phi i32 [ 0, %entry ], [ %r3, %loop.latch ]
+  %arrayidx = getelementptr inbounds i32, i32* %src, i64 %iv
+  %src_element = load i32, i32* %arrayidx, align 4
+  %cmp = icmp eq i32 0, %src_element
+  br i1 %cmp, label %loop.if, label %loop.latch
+
+loop.if:
+  %r2 = add i32 %r1, 1
+  br label %loop.latch
+loop.latch:
+  %r3 = phi i32 [%r1, %loop.header], [%r2, %loop.if]
+  %inc = add nuw nsw i64 %iv, 1
+  %exitcond = icmp eq i64 %inc, 9
+  br i1 %exitcond, label %loop.end, label %loop.header
+loop.end:
+  %r.lcssa = phi i32 [ %r3, %loop.latch ]
+  ret i32 %r.lcssa
+}
+"""
+
+
+module = llvm.parse_assembly(strmod)
+
+print("Module before optimization:\n")
+print(module)
+
+# Set up the module pass manager used to run our optimization pipeline.
+# We create it unpopulated, and then add the loop unroll and simplify CFG
+# passes.
+pm = llvm.create_new_module_pass_manager()
+pm.add_loop_unroll_pass()
+pm.add_simplify_cfg_pass()
+
+
+# To run the pass manager, we need a pass builder object - we create pipeline
+# tuning options with no optimization, then use that to create a pass builder.
+target_machine = llvm.Target.from_default_triple().create_target_machine()
+pto = llvm.create_pipeline_tuning_options(speed_level=0)
+pb = llvm.create_pass_builder(target_machine, pto)
+
+# Now we can run the pass manager on our module
+pm.run(module, pb)
+
+
+# We should observer a fully unrolled loop, and the function now consists of a
+# single basic block executing all the iterations of the loop in a straight
+# line.
+print("\nModule after optimization:\n")
+print(module)

llvmlite-0.44.0rc2/examples/npm_pipeline.py

@@ -0,0 +1,87 @@
+"""
+This example demonstrates how to optimize a module with a module pass manager
+pre-populated with passes according to a given optimization level.
+
+The optimized module is executed using the MCJIT bindings.
+"""
+
+from ctypes import CFUNCTYPE, c_int, POINTER
+import faulthandler
+import llvmlite.binding as llvm
+
+import numpy as np
+
+# Dump Python traceback in the event of a segfault
+faulthandler.enable()
+
+# All are required to initialize LLVM
+llvm.initialize()
+llvm.initialize_native_target()
+llvm.initialize_native_asmprinter()
+
+# Module to optimize and execute
+strmod = """
+; ModuleID = '<string>'
+source_filename = "<string>"
+target triple = "unknown-unknown-unknown"
+
+define i32 @sum(i32* %.1, i32 %.2) {
+.4:
+  br label %.5
+
+.5:                                               ; preds = %.5, %.4
+  %.8 = phi i32 [ 0, %.4 ], [ %.13, %.5 ]
+  %.9 = phi i32 [ 0, %.4 ], [ %.12, %.5 ]
+  %.10 = getelementptr i32, i32* %.1, i32 %.8
+  %.11 = load i32, i32* %.10, align 4
+  %.12 = add i32 %.9, %.11
+  %.13 = add i32 %.8, 1
+  %.14 = icmp ult i32 %.13, %.2
+  br i1 %.14, label %.5, label %.6
+
+.6:                                               ; preds = %.5
+  ret i32 %.12
+}
+"""
+
+
+module = llvm.parse_assembly(strmod)
+
+print("Module before optimization:\n")
+print(module)
+
+# Create a ModulePassManager for speed optimization level 3
+target_machine = llvm.Target.from_default_triple().create_target_machine()
+pto = llvm.create_pipeline_tuning_options(speed_level=3)
+pb = llvm.create_pass_builder(target_machine, pto)
+pm = pb.getModulePassManager()
+
+# Run the optimization pipeline on the module
+pm.run(module, pb)
+
+# O3 optimization will likely have vectorized the loop. The resulting code will
+# be more complex, but more performant.
+print("\nModule after optimization:\n")
+print(module)
+
+with llvm.create_mcjit_compiler(module, target_machine) as ee:
+    # Generate code and get a pointer to it for calling
+    ee.finalize_object()
+    cfptr = ee.get_function_address("sum")
+
+    # We should also observe vector instructions in the generated assembly
+    print("\nAssembly code generated from module\n")
+    print(target_machine.emit_assembly(module))
+
+    # Create an array of integers and call our optimized sum function with them
+    cfunc = CFUNCTYPE(c_int, POINTER(c_int), c_int)(cfptr)
+    A = np.arange(10, dtype=np.int32)
+    res = cfunc(A.ctypes.data_as(POINTER(c_int)), A.size)
+
+    # Print results, which should be identical
+    print(f"Result of executing the optimized function: {res}")
+    print(f"Expected result: {A.sum()}")
+
+    # Sanity check
+    np.testing.assert_equal(res, A.sum())
+    print("Success!")

llvmlite-0.44.0rc2/examples/opaque_pointers/llvmir.py

@@ -0,0 +1,38 @@
+import llvmlite
+llvmlite.opaque_pointers_enabled = True
+
+import llvmlite.ir as ll
+
+fntype = ll.FunctionType(ll.IntType(32), [ll.IntType(32), ll.IntType(32)])
+
+module = ll.Module()
+
+func = ll.Function(module, fntype, name='foo')
+bb_entry = func.append_basic_block()
+
+builder = ll.IRBuilder()
+builder.position_at_end(bb_entry)
+
+stackint = builder.alloca(ll.IntType(32))
+# Instead of stackint.type.pointee we can access stackint.allocated_type
+# directly.
+builder.store(ll.Constant(stackint.allocated_type, 123), stackint)
+myint = builder.load(stackint)
+
+addinstr = builder.add(func.args[0], func.args[1])
+mulinstr = builder.mul(addinstr, ll.Constant(ll.IntType(32), 123))
+pred = builder.icmp_signed('<', addinstr, mulinstr)
+builder.ret(mulinstr)
+
+bb_block = func.append_basic_block()
+builder.position_at_end(bb_block)
+
+bb_exit = func.append_basic_block()
+
+pred = builder.trunc(addinstr, ll.IntType(1))
+builder.cbranch(pred, bb_block, bb_exit)
+
+builder.position_at_end(bb_exit)
+builder.ret(myint)
+
+print(module)

llvmlite-0.44.0rc2/examples/opaque_pointers/sum.py

@@ -0,0 +1,115 @@
+from __future__ import print_function
+
+from ctypes import CFUNCTYPE, c_int, POINTER
+import sys
+try:
+    from time import perf_counter as time
+except ImportError:
+    from time import time
+
+import numpy as np
+
+try:
+    import faulthandler; faulthandler.enable()
+except ImportError:
+    pass
+
+import llvmlite
+llvmlite.opaque_pointers_enabled = True
+
+import llvmlite.ir as ll
+import llvmlite.binding as llvm
+
+
+llvm.initialize()
+llvm.initialize_native_target()
+llvm.initialize_native_asmprinter()
+
+
+t1 = time()
+
+# Pointers are opaque, so we should define them as such here.
+fnty = ll.FunctionType(ll.IntType(32), [ll.PointerType(), ll.IntType(32)])
+module = ll.Module()
+
+func = ll.Function(module, fnty, name="sum")
+
+bb_entry = func.append_basic_block()
+bb_loop = func.append_basic_block()
+bb_exit = func.append_basic_block()
+
+builder = ll.IRBuilder()
+builder.position_at_end(bb_entry)
+
+builder.branch(bb_loop)
+builder.position_at_end(bb_loop)
+
+index = builder.phi(ll.IntType(32))
+index.add_incoming(ll.Constant(index.type, 0), bb_entry)
+accum = builder.phi(ll.IntType(32))
+accum.add_incoming(ll.Constant(accum.type, 0), bb_entry)
+
+# These GEP and load need an excplicit type.
+ptr = builder.gep(func.args[0], [index], source_etype=ll.IntType(32))
+value = builder.load(ptr, typ=ll.IntType(32))
+
+added = builder.add(accum, value)
+accum.add_incoming(added, bb_loop)
+
+indexp1 = builder.add(index, ll.Constant(index.type, 1))
+index.add_incoming(indexp1, bb_loop)
+
+cond = builder.icmp_unsigned('<', indexp1, func.args[1])
+builder.cbranch(cond, bb_loop, bb_exit)
+
+builder.position_at_end(bb_exit)
+builder.ret(added)
+
+strmod = str(module)
+
+t2 = time()
+
+print("-- generate IR:", t2-t1)
+
+t3 = time()
+
+llmod = llvm.parse_assembly(strmod)
+
+t4 = time()
+
+print("-- parse assembly:", t4-t3)
+
+print(llmod)
+
+pmb = llvm.create_pass_manager_builder()
+pmb.opt_level = 2
+pm = llvm.create_module_pass_manager()
+pmb.populate(pm)
+
+t5 = time()
+
+pm.run(llmod)
+
+t6 = time()
+
+print("-- optimize:", t6-t5)
+
+t7 = time()
+
+target_machine = llvm.Target.from_default_triple().create_target_machine()
+
+with llvm.create_mcjit_compiler(llmod, target_machine) as ee:
+    ee.finalize_object()
+    cfptr = ee.get_function_address("sum")
+
+    t8 = time()
+    print("-- JIT compile:", t8 - t7)
+
+    print(target_machine.emit_assembly(llmod))
+
+    cfunc = CFUNCTYPE(c_int, POINTER(c_int), c_int)(cfptr)
+    A = np.arange(10, dtype=np.int32)
+    res = cfunc(A.ctypes.data_as(POINTER(c_int)), A.size)
+
+    print(res, A.sum())
+

{llvmlite-0.43.0rc1 → llvmlite-0.44.0rc2}/ffi/CMakeLists.txt

@@ -11,6 +11,8 @@ if(NOT MSVC)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -g")
 endif()
 
+set(CMAKE_CXX_STANDARD 17)
+
 # Work around llvm/llvm-project#83802 - LLVM's Findzstd.cmake uses variables
 # that require including `GNUInstallDirs`, but it does not include it itself.
 include(GNUInstallDirs)
@@ -44,7 +46,7 @@ endif()
 add_library(llvmlite SHARED assembly.cpp bitcode.cpp core.cpp initfini.cpp
             module.cpp value.cpp executionengine.cpp transforms.cpp type.cpp
             passmanagers.cpp targets.cpp dylib.cpp linker.cpp object_file.cpp
-            custom_passes.cpp orcjit.cpp memorymanager.cpp)
+            custom_passes.cpp orcjit.cpp memorymanager.cpp newpassmanagers.cpp)
 
 # Find the libraries that correspond to the LLVM components
 # that we wish to use.

{llvmlite-0.43.0rc1 → llvmlite-0.44.0rc2}/ffi/Makefile.freebsd

@@ -12,7 +12,7 @@ INCLUDE = core.h
 SRC = assembly.cpp bitcode.cpp core.cpp initfini.cpp module.cpp value.cpp \
 	executionengine.cpp transforms.cpp passmanagers.cpp type.cpp targets.cpp \
 	dylib.cpp linker.cpp object_file.cpp orcjit.cpp custom_passes.cpp \
-	memorymanager.cpp
+	memorymanager.cpp newpassmanagers.cpp
 OUTPUT = libllvmlite.so
 
 all: $(OUTPUT)

{llvmlite-0.43.0rc1 → llvmlite-0.44.0rc2}/ffi/Makefile.linux

@@ -13,7 +13,7 @@ LIBS = $(LLVM_LIBS)
 INCLUDE = core.h
 OBJ = assembly.o bitcode.o core.o initfini.o module.o value.o \
 	  executionengine.o transforms.o passmanagers.o targets.o type.o dylib.o \
-	  linker.o object_file.o custom_passes.o orcjit.o memorymanager.o
+	  linker.o object_file.o custom_passes.o orcjit.o memorymanager.o newpassmanagers.o
 OUTPUT = libllvmlite.so
 
 all: $(OUTPUT)

llvmlite-0.44.0rc2/ffi/Makefile.netbsd

@@ -0,0 +1,24 @@
+
+CXX = clang++
+
+# -flto and --exclude-libs allow us to remove those parts of LLVM we don't use
+CXX_FLTO_FLAGS ?= -flto
+LD_FLTO_FLAGS ?= -flto -Wl,--exclude-libs=ALL
+
+CXXFLAGS := $(CPPFLAGS) $(CXXFLAGS) $(LLVM_CXXFLAGS) $(CXX_FLTO_FLAGS)
+LDFLAGS := $(LDFLAGS) $(LLVM_LDFLAGS) $(LD_FLTO_FLAGS)
+LIBS = $(LLVM_LIBS)
+INCLUDE = core.h
+SRC = assembly.cpp bitcode.cpp core.cpp initfini.cpp module.cpp value.cpp \
+	executionengine.cpp transforms.cpp passmanagers.cpp type.cpp targets.cpp \
+	dylib.cpp linker.cpp object_file.cpp orcjit.cpp custom_passes.cpp \
+	memorymanager.cpp newpassmanagers.cpp
+OUTPUT = libllvmlite.so
+
+all: $(OUTPUT)
+
+$(OUTPUT): $(SRC) $(INCLUDE)
+	$(CXX) -shared $(CXXFLAGS) $(SRC) -o $(OUTPUT) $(LDFLAGS) $(LIBS)
+
+clean:
+	rm -rf test

{llvmlite-0.43.0rc1 → llvmlite-0.44.0rc2}/ffi/Makefile.osx

@@ -9,7 +9,7 @@ INCLUDE = core.h
 SRC = assembly.cpp bitcode.cpp core.cpp initfini.cpp module.cpp value.cpp \
 	  executionengine.cpp transforms.cpp passmanagers.cpp targets.cpp type.cpp \
 	  dylib.cpp linker.cpp object_file.cpp custom_passes.cpp orcjit.cpp \
-	  memorymanager.cpp
+	  memorymanager.cpp newpassmanagers.cpp
 OUTPUT = libllvmlite.dylib
 MACOSX_DEPLOYMENT_TARGET ?= 10.9
 

{llvmlite-0.43.0rc1 → llvmlite-0.44.0rc2}/ffi/build.py

@@ -99,7 +99,28 @@ def find_windows_generator():
     raise RuntimeError("No compatible cmake generator installed on this machine")
 
 
+def remove_msvc_whole_program_optimization():
+    """Remove MSVC whole-program optimization flags.
+    This workaround a segfault issue on windows.
+    Note: conda-build is known to enable the `-GL` flag.
+    """
+    def drop_gl(flags):
+        try:
+            flags.remove('-GL')
+        except ValueError:
+            pass
+        else:
+            print(f"removed '-GL' flag in {flags}")
+    cflags = os.environ.get('CFLAGS', '').split(' ')
+    cxxflags = os.environ.get('CXXFLAGS', '').split(' ')
+    drop_gl(cflags)
+    drop_gl(cxxflags)
+    os.environ['CFLAGS'] = ' '.join(cflags)
+    os.environ['CXXFLAGS'] = ' '.join(cxxflags)
+
+
 def main_windows():
+    remove_msvc_whole_program_optimization()
     generator = find_windows_generator()
     config = 'Release'
     if not os.path.exists(build_dir):
@@ -167,13 +188,13 @@ def main_posix(kind, library_ext):
     else:
         (version, _) = out.split('.', 1)
         version = int(version)
-        if version == 15:
-            msg = ("Building with LLVM 15; note that LLVM 15 support is "
+        if version == 16:
+            msg = ("Building with LLVM 16; note that LLVM 16 support is "
                    "presently experimental")
             show_warning(msg)
-        elif version != 14:
+        elif version != 15:
 
-            msg = ("Building llvmlite requires LLVM 14, got "
+            msg = ("Building llvmlite requires LLVM 15, got "
                    "{!r}. Be sure to set LLVM_CONFIG to the right executable "
                    "path.\nRead the documentation at "
                    "http://llvmlite.pydata.org/ for more information about "
@@ -225,6 +246,8 @@ def main():
         main_posix('linux', '.so')
     elif sys.platform.startswith(('freebsd','openbsd')):
         main_posix('freebsd', '.so')
+    elif sys.platform.startswith('netbsd'):
+        main_posix('netbsd', '.so')
     elif sys.platform == 'darwin':
         main_posix('osx', '.dylib')
     else:

{llvmlite-0.43.0rc1 → llvmlite-0.44.0rc2}/ffi/core.cpp

@@ -20,21 +20,19 @@ LLVMPY_CreateByteString(const char *buf, size_t len) {
 API_EXPORT(void)
 LLVMPY_DisposeString(const char *msg) { free(const_cast<char *>(msg)); }
 
+// FIXME: Remove `enableOpaquePointers' once typed pointers are removed.
 API_EXPORT(LLVMContextRef)
-LLVMPY_GetGlobalContext() {
+LLVMPY_GetGlobalContext(bool enableOpaquePointers) {
     auto context = LLVMGetGlobalContext();
-#if LLVM_VERSION_MAJOR > 14
-    LLVMContextSetOpaquePointers(context, false);
-#endif
+    LLVMContextSetOpaquePointers(context, enableOpaquePointers);
     return context;
 }
 
+// FIXME: Remove `enableOpaquePointers' once typed pointers are removed.
 API_EXPORT(LLVMContextRef)
-LLVMPY_ContextCreate() {
+LLVMPY_ContextCreate(bool enableOpaquePointers) {
     LLVMContextRef context = LLVMContextCreate();
-#if LLVM_VERSION_MAJOR > 14
-    LLVMContextSetOpaquePointers(context, false);
-#endif
+    LLVMContextSetOpaquePointers(context, enableOpaquePointers);
     return context;
 }
 

{llvmlite-0.43.0rc1 → llvmlite-0.44.0rc2}/ffi/core.h

@@ -31,11 +31,13 @@ LLVMPY_CreateByteString(const char *buf, size_t len);
 API_EXPORT(void)
 LLVMPY_DisposeString(const char *msg);
 
+// FIXME: Remove `enableOpaquePointers' once typed pointers are removed.
 API_EXPORT(LLVMContextRef)
-LLVMPY_GetGlobalContext();
+LLVMPY_GetGlobalContext(bool enableOpaquePointers);
 
+// FIXME: Remove `enableOpaquePointers' once typed pointers are removed.
 API_EXPORT(LLVMContextRef)
-LLVMPY_ContextCreate();
+LLVMPY_ContextCreate(bool enableOpaquePointers);
 
 } /* end extern "C" */