llvmlite 0.44.0rc1__cp311-cp311-macosx_11_0_arm64.whl → 0.45.0__cp311-cp311-macosx_11_0_arm64.whl

llvmlite/tests/test_binding.py

@@ -18,14 +18,29 @@ from llvmlite import binding as llvm
 from llvmlite.binding import ffi
 from llvmlite.tests import TestCase
 
-# FIXME: Remove me once typed pointers are no longer supported.
-from llvmlite import opaque_pointers_enabled
-
 # arvm7l needs extra ABI symbols to link successfully
 if platform.machine() == 'armv7l':
     llvm.load_library_permanently('libgcc_s.so.1')
 
 
+is_conda_package = unittest.skipUnless(llvm.package_format == "conda",
+                                       ("conda package test only, have "
+                                        f"{llvm.package_format}"))
+is_wheel_package = unittest.skipUnless(llvm.package_format == "wheel",
+                                       ("wheel package test only, have "
+                                        f"{llvm.package_format}"))
+
+_HAVE_LIEF = False
+try:
+    import lief  # noqa: F401
+    _HAVE_LIEF = True
+except ImportError:
+    pass
+
+
+needs_lief = unittest.skipUnless(_HAVE_LIEF, "test needs py-lief package")
+
+
 def no_de_locale():
     cur = locale.setlocale(locale.LC_ALL)
     try:
@@ -415,11 +430,11 @@ riscv_asm_ilp32 = [
     'addi\tsp, sp, -16',
     'sw\ta1, 8(sp)',
     'sw\ta2, 12(sp)',
-    'fld\tft0, 8(sp)',
-    'fmv.w.x\tft1, a0',
-    'fcvt.d.s\tft1, ft1',
-    'fadd.d\tft0, ft1, ft0',
-    'fsd\tft0, 8(sp)',
+    'fld\tfa5, 8(sp)',
+    'fmv.w.x\tfa4, a0',
+    'fcvt.d.s\tfa4, fa4',
+    'fadd.d\tfa5, fa4, fa5',
+    'fsd\tfa5, 8(sp)',
     'lw\ta0, 8(sp)',
     'lw\ta1, 12(sp)',
     'addi\tsp, sp, 16',
@@ -431,10 +446,10 @@ riscv_asm_ilp32f = [
     'addi\tsp, sp, -16',
     'sw\ta0, 8(sp)',
     'sw\ta1, 12(sp)',
-    'fld\tft0, 8(sp)',
-    'fcvt.d.s\tft1, fa0',
-    'fadd.d\tft0, ft1, ft0',
-    'fsd\tft0, 8(sp)',
+    'fld\tfa5, 8(sp)',
+    'fcvt.d.s\tfa4, fa0',
+    'fadd.d\tfa5, fa4, fa5',
+    'fsd\tfa5, 8(sp)',
     'lw\ta0, 8(sp)',
     'lw\ta1, 12(sp)',
     'addi\tsp, sp, 16',
@@ -443,8 +458,8 @@ riscv_asm_ilp32f = [
 
 
 riscv_asm_ilp32d = [
-    'fcvt.d.s\tft0, fa0',
-    'fadd.d\tfa0, ft0, fa1',
+    'fcvt.d.s\tfa5, fa0',
+    'fadd.d\tfa0, fa5, fa1',
     'ret'
 ]
 
@@ -654,7 +669,6 @@ attributes #1 = { argmemonly nofree nounwind willreturn }
 class BaseTest(TestCase):
 
     def setUp(self):
-        llvm.initialize()
         llvm.initialize_native_target()
         llvm.initialize_native_asmprinter()
         gc.collect()
@@ -718,13 +732,21 @@ class TestDependencies(BaseTest):
             self.fail("failed parsing dependencies? got %r" % (deps,))
         # Ensure all dependencies are expected
         allowed = set(['librt', 'libdl', 'libpthread', 'libz', 'libm',
-                       'libgcc_s', 'libc', 'ld-linux', 'ld64'])
+                       'libgcc_s', 'libc', 'ld-linux', 'ld64', 'libzstd',
+                       'libstdc++'])
         if platform.python_implementation() == 'PyPy':
             allowed.add('libtinfo')
 
+        fails = []
         for dep in deps:
             if not dep.startswith('ld-linux-') and dep not in allowed:
-                self.fail("unexpected dependency %r in %r" % (dep, deps))
+                fails.append(dep)
+        if len(fails) == 1:
+            self.fail("unexpected dependency %r in %r" % (fails[0], deps))
+        elif len(fails) > 1:
+            self.fail("unexpected dependencies %r in %r" % (fails, deps))
+        else:
+            pass  # test passes
 
 
 class TestRISCVABI(BaseTest):
@@ -892,7 +914,6 @@ class TestMisc(BaseTest):
         code = """if 1:
             from llvmlite import binding as llvm
 
-            llvm.initialize()
             llvm.initialize_native_target()
             llvm.initialize_native_asmprinter()
             llvm.initialize_all_targets()
@@ -901,6 +922,11 @@ class TestMisc(BaseTest):
             """
         subprocess.check_call([sys.executable, "-c", code])
 
+    def test_deprecated_init(self):
+        regex = r"llvmlite.binding.initialize\(\) is deprecated"
+        with self.assertRaisesRegex(RuntimeError, expected_regex=regex):
+            llvm.initialize()
+
     def test_set_option(self):
         # We cannot set an option multiple times (LLVM would exit() the
         # process), so run the code in a subprocess.
@@ -914,9 +940,9 @@ class TestMisc(BaseTest):
     def test_version(self):
         major, minor, patch = llvm.llvm_version_info
         # one of these can be valid
-        valid = (15, 16)
+        valid = (20,)
         self.assertIn(major, valid)
-        self.assertIn(patch, range(8))
+        self.assertIn(patch, range(9))
 
     def test_check_jit_execution(self):
         llvm.check_jit_execution()
@@ -1361,7 +1387,10 @@ class TestMCJit(BaseTest, JITWithTMTestMixin):
 # #1000. Since OrcJIT is experimental, and we don't test regularly during
 # llvmlite development on non-x86 platforms, it seems safest to skip these
 # tests on non-x86 platforms.
-@unittest.skipUnless(platform.machine().startswith("x86"), "x86 only")
+# After LLVM20 upgrades skip on X86 too as ORCJit complains about missing
+# JITDyLib symbol.
+# TODO: Investigate this further.
+@unittest.skip("OrcJIT support is experimental")
 class TestOrcLLJIT(BaseTest):
 
     def jit(self, asm=asm_sum, func_name="sum", target_machine=None,
@@ -1647,12 +1676,7 @@ class TestValueRef(BaseTest):
         mod = self.module()
         st = mod.get_global_variable("glob_struct")
         self.assertTrue(st.type.is_pointer)
-        # FIXME: Remove `else' once TP are no longer supported.
-        if opaque_pointers_enabled:
-            self.assertIsNotNone(re.match(r'ptr', str(st.type)))
-        else:
-            self.assertIsNotNone(re.match(r'%struct\.glob_type(\.[\d]+)?\*',
-                                          str(st.type)))
+        self.assertIsNotNone(re.match(r'ptr', str(st.type)))
         self.assertIsNotNone(re.match(
             r"%struct\.glob_type(\.[\d]+)? = type { i64, \[2 x i64\] }",
             str(st.global_value_type)))
@@ -1741,7 +1765,7 @@ class TestValueRef(BaseTest):
 
     def test_function_attributes(self):
         ver = llvm.llvm_version_info[0]
-        readonly_attrs = [b'memory(read)' if ver == 16 else b'readonly']
+        readonly_attrs = [b'memory(read)' if ver > 15 else b'readonly']
         mod = self.module(asm_attributes)
         for func in mod.functions:
             attrs = list(func.attributes)
@@ -1841,11 +1865,7 @@ class TestValueRef(BaseTest):
         inst = list(list(func.blocks)[0].instructions)[0]
         arg = list(inst.operands)[0]
         self.assertTrue(arg.is_constant)
-        # FIXME: Remove `else' once TP are no longer supported.
-        if opaque_pointers_enabled:
-            self.assertEqual(arg.get_constant_value(), 'ptr null')
-        else:
-            self.assertEqual(arg.get_constant_value(), 'i64* null')
+        self.assertEqual(arg.get_constant_value(), 'ptr null')
 
     def test_incoming_phi_blocks(self):
         mod = self.module(asm_phi_blocks)
@@ -1950,12 +1970,7 @@ class TestTypeRef(BaseTest):
         self.assertTrue(func.type.is_pointer)
         with self.assertRaises(ValueError) as raises:
             func.type.is_function_vararg
-        # FIXME: Remove `else' once TP are no longer supported.
-        if opaque_pointers_enabled:
-            self.assertIn("Type ptr is not a function", str(raises.exception))
-        else:
-            self.assertIn("Type i32 (i32, i32)* is not a function",
-                          str(raises.exception))
+        self.assertIn("Type ptr is not a function", str(raises.exception))
 
     def test_function_typeref_as_ir(self):
         mod = self.module()
@@ -2244,11 +2259,6 @@ class TestTargetData(BaseTest):
 
 class TestTargetMachine(BaseTest):
 
-    def test_add_analysis_passes(self):
-        tm = self.target_machine(jit=False)
-        pm = llvm.create_module_pass_manager()
-        tm.add_analysis_passes(pm)
-
     def test_target_data_from_tm(self):
         tm = self.target_machine(jit=False)
         td = tm.target_data
@@ -2259,370 +2269,6 @@ class TestTargetMachine(BaseTest):
         self.assertEqual(td.get_abi_size(gv_i32.type), pointer_size)
 
 
-class TestPassManagerBuilder(BaseTest):
-
-    def pmb(self):
-        return llvm.PassManagerBuilder()
-
-    def test_old_api(self):
-        # Test the create_pass_manager_builder() factory function
-        pmb = llvm.create_pass_manager_builder()
-        pmb.inlining_threshold = 2
-        pmb.opt_level = 3
-
-    def test_close(self):
-        pmb = self.pmb()
-        pmb.close()
-        pmb.close()
-
-    def test_opt_level(self):
-        pmb = self.pmb()
-        self.assertIsInstance(pmb.opt_level, int)
-        for i in range(4):
-            pmb.opt_level = i
-            self.assertEqual(pmb.opt_level, i)
-
-    def test_size_level(self):
-        pmb = self.pmb()
-        self.assertIsInstance(pmb.size_level, int)
-        for i in range(4):
-            pmb.size_level = i
-            self.assertEqual(pmb.size_level, i)
-
-    def test_inlining_threshold(self):
-        pmb = self.pmb()
-        with self.assertRaises(NotImplementedError):
-            pmb.inlining_threshold
-        for i in (25, 80, 350):
-            pmb.inlining_threshold = i
-
-    def test_disable_unroll_loops(self):
-        pmb = self.pmb()
-        self.assertIsInstance(pmb.disable_unroll_loops, bool)
-        for b in (True, False):
-            pmb.disable_unroll_loops = b
-            self.assertEqual(pmb.disable_unroll_loops, b)
-
-    def test_loop_vectorize(self):
-        pmb = self.pmb()
-        self.assertIsInstance(pmb.loop_vectorize, bool)
-        for b in (True, False):
-            pmb.loop_vectorize = b
-            self.assertEqual(pmb.loop_vectorize, b)
-
-    def test_slp_vectorize(self):
-        pmb = self.pmb()
-        self.assertIsInstance(pmb.slp_vectorize, bool)
-        for b in (True, False):
-            pmb.slp_vectorize = b
-            self.assertEqual(pmb.slp_vectorize, b)
-
-    def test_populate_module_pass_manager(self):
-        pmb = self.pmb()
-        pm = llvm.create_module_pass_manager()
-        pmb.populate(pm)
-        pmb.close()
-        pm.close()
-
-    def test_populate_function_pass_manager(self):
-        mod = self.module()
-        pmb = self.pmb()
-        pm = llvm.create_function_pass_manager(mod)
-        pmb.populate(pm)
-        pmb.close()
-        pm.close()
-
-
-class PassManagerTestMixin(object):
-
-    def pmb(self):
-        pmb = llvm.create_pass_manager_builder()
-        pmb.opt_level = 2
-        pmb.inlining_threshold = 300
-        return pmb
-
-    def test_close(self):
-        pm = self.pm()
-        pm.close()
-        pm.close()
-
-
-class TestModulePassManager(BaseTest, PassManagerTestMixin):
-
-    def pm(self):
-        return llvm.create_module_pass_manager()
-
-    def test_run(self):
-        pm = self.pm()
-        self.pmb().populate(pm)
-        mod = self.module()
-        orig_asm = str(mod)
-        pm.run(mod)
-        opt_asm = str(mod)
-        # Quick check that optimizations were run, should get:
-        # define i32 @sum(i32 %.1, i32 %.2) local_unnamed_addr #0 {
-        # %.X = add i32 %.2, %.1
-        # ret i32 %.X
-        # }
-        # where X in %.X is 3 or 4
-        opt_asm_split = opt_asm.splitlines()
-        for idx, l in enumerate(opt_asm_split):
-            if l.strip().startswith('ret i32'):
-                toks = {'%.3', '%.4'}
-                for t in toks:
-                    if t in l:
-                        break
-                else:
-                    raise RuntimeError("expected tokens not found")
-                othertoken = (toks ^ {t}).pop()
-
-                self.assertIn("%.3", orig_asm)
-                self.assertNotIn(othertoken, opt_asm)
-                break
-        else:
-            raise RuntimeError("expected IR not found")
-
-    def test_run_with_remarks_successful_inline(self):
-        pm = self.pm()
-        pm.add_function_inlining_pass(70)
-        self.pmb().populate(pm)
-        mod = self.module(asm_inlineasm2)
-        (status, remarks) = pm.run_with_remarks(mod)
-        self.assertTrue(status)
-        # Inlining has happened?  The remark will tell us.
-        self.assertIn("Passed", remarks)
-        self.assertIn("inlineme", remarks)
-
-    def test_run_with_remarks_failed_inline(self):
-        pm = self.pm()
-        pm.add_function_inlining_pass(0)
-        self.pmb().populate(pm)
-        mod = self.module(asm_inlineasm3)
-        (status, remarks) = pm.run_with_remarks(mod)
-        self.assertTrue(status)
-
-        # Inlining has not happened?  The remark will tell us.
-        self.assertIn("Missed", remarks)
-        self.assertIn("inlineme", remarks)
-        self.assertIn("noinline function attribute", remarks)
-
-    def test_run_with_remarks_inline_filter_out(self):
-        pm = self.pm()
-        pm.add_function_inlining_pass(70)
-        self.pmb().populate(pm)
-        mod = self.module(asm_inlineasm2)
-        (status, remarks) = pm.run_with_remarks(mod, remarks_filter="nothing")
-        self.assertTrue(status)
-        self.assertEqual("", remarks)
-
-    def test_run_with_remarks_inline_filter_in(self):
-        pm = self.pm()
-        pm.add_function_inlining_pass(70)
-        self.pmb().populate(pm)
-        mod = self.module(asm_inlineasm2)
-        (status, remarks) = pm.run_with_remarks(mod, remarks_filter="inlin.*")
-        self.assertTrue(status)
-        self.assertIn("Passed", remarks)
-        self.assertIn("inlineme", remarks)
-
-
-class TestFunctionPassManager(BaseTest, PassManagerTestMixin):
-
-    def pm(self, mod=None):
-        mod = mod or self.module()
-        return llvm.create_function_pass_manager(mod)
-
-    def test_initfini(self):
-        pm = self.pm()
-        pm.initialize()
-        pm.finalize()
-
-    def test_run(self):
-        mod = self.module()
-        fn = mod.get_function("sum")
-        pm = self.pm(mod)
-        self.pmb().populate(pm)
-        mod.close()
-        orig_asm = str(fn)
-        pm.initialize()
-        pm.run(fn)
-        pm.finalize()
-        opt_asm = str(fn)
-        # Quick check that optimizations were run
-        self.assertIn("%.4", orig_asm)
-        self.assertNotIn("%.4", opt_asm)
-
-    def test_run_with_remarks(self):
-        mod = self.module(licm_asm)
-        fn = mod.get_function("licm")
-        pm = self.pm(mod)
-        pm.add_licm_pass()
-        self.pmb().populate(pm)
-        mod.close()
-
-        pm.initialize()
-        (ok, remarks) = pm.run_with_remarks(fn)
-        pm.finalize()
-        self.assertTrue(ok)
-        self.assertIn("Passed", remarks)
-        self.assertIn("licm", remarks)
-
-    def test_run_with_remarks_filter_out(self):
-        mod = self.module(licm_asm)
-        fn = mod.get_function("licm")
-        pm = self.pm(mod)
-        pm.add_licm_pass()
-        self.pmb().populate(pm)
-        mod.close()
-
-        pm.initialize()
-        (ok, remarks) = pm.run_with_remarks(fn, remarks_filter="nothing")
-        pm.finalize()
-        self.assertTrue(ok)
-        self.assertEqual("", remarks)
-
-    def test_run_with_remarks_filter_in(self):
-        mod = self.module(licm_asm)
-        fn = mod.get_function("licm")
-        pm = self.pm(mod)
-        pm.add_licm_pass()
-        self.pmb().populate(pm)
-        mod.close()
-
-        pm.initialize()
-        (ok, remarks) = pm.run_with_remarks(fn, remarks_filter="licm")
-        pm.finalize()
-        self.assertTrue(ok)
-        self.assertIn("Passed", remarks)
-        self.assertIn("licm", remarks)
-
-
-class TestPasses(BaseTest, PassManagerTestMixin):
-
-    def pm(self):
-        return llvm.create_module_pass_manager()
-
-    def test_populate(self):
-        llvm_ver = llvm.llvm_version_info[0]
-
-        pm = self.pm()
-        pm.add_target_library_info("") # unspecified target triple
-        pm.add_constant_merge_pass()
-        pm.add_dead_arg_elimination_pass()
-        pm.add_function_attrs_pass()
-        pm.add_function_inlining_pass(225)
-        pm.add_global_dce_pass()
-        pm.add_global_optimizer_pass()
-        pm.add_ipsccp_pass()
-        pm.add_dead_code_elimination_pass()
-        pm.add_cfg_simplification_pass()
-        pm.add_gvn_pass()
-        pm.add_instruction_combining_pass()
-        pm.add_licm_pass()
-        pm.add_sccp_pass()
-        pm.add_sroa_pass()
-        pm.add_type_based_alias_analysis_pass()
-        pm.add_basic_alias_analysis_pass()
-        pm.add_loop_rotate_pass()
-        pm.add_region_info_pass()
-        pm.add_scalar_evolution_aa_pass()
-        pm.add_aggressive_dead_code_elimination_pass()
-        pm.add_aa_eval_pass()
-        pm.add_always_inliner_pass()
-        pm.add_break_critical_edges_pass()
-        pm.add_dead_store_elimination_pass()
-        pm.add_reverse_post_order_function_attrs_pass()
-
-        if llvm_ver < 16:
-            pm.add_aggressive_instruction_combining_pass()
-
-        pm.add_internalize_pass()
-        pm.add_jump_threading_pass(7)
-        pm.add_lcssa_pass()
-        pm.add_loop_deletion_pass()
-        pm.add_loop_extractor_pass()
-        pm.add_single_loop_extractor_pass()
-        pm.add_loop_strength_reduce_pass()
-        pm.add_loop_simplification_pass()
-        pm.add_loop_unroll_pass()
-        pm.add_loop_unroll_and_jam_pass()
-        pm.add_lower_atomic_pass()
-        pm.add_lower_invoke_pass()
-        pm.add_lower_switch_pass()
-        pm.add_memcpy_optimization_pass()
-        pm.add_merge_functions_pass()
-        pm.add_merge_returns_pass()
-        pm.add_partial_inlining_pass()
-
-        if llvm_ver < 16:
-            pm.add_prune_exception_handling_pass()
-
-        pm.add_reassociate_expressions_pass()
-        pm.add_demote_register_to_memory_pass()
-        pm.add_sink_pass()
-        pm.add_strip_symbols_pass()
-        pm.add_strip_dead_debug_info_pass()
-        pm.add_strip_dead_prototypes_pass()
-        pm.add_strip_debug_declare_pass()
-        pm.add_strip_nondebug_symbols_pass()
-        pm.add_tail_call_elimination_pass()
-        pm.add_basic_aa_pass()
-        pm.add_dependence_analysis_pass()
-        pm.add_dot_call_graph_pass()
-        pm.add_dot_cfg_printer_pass()
-        pm.add_dot_dom_printer_pass()
-        pm.add_dot_postdom_printer_pass()
-        pm.add_globals_mod_ref_aa_pass()
-        pm.add_iv_users_pass()
-        pm.add_lazy_value_info_pass()
-        pm.add_lint_pass()
-        pm.add_module_debug_info_pass()
-        pm.add_refprune_pass()
-        pm.add_instruction_namer_pass()
-
-    @unittest.skipUnless(platform.machine().startswith("x86"), "x86 only")
-    def test_target_library_info_behavior(self):
-        """Test a specific situation that demonstrate TLI is affecting
-        optimization. See https://github.com/numba/numba/issues/8898.
-        """
-        def run(use_tli):
-            mod = llvm.parse_assembly(asm_tli_exp2)
-            target = llvm.Target.from_triple(mod.triple)
-            tm = target.create_target_machine()
-            pm = llvm.ModulePassManager()
-            tm.add_analysis_passes(pm)
-            if use_tli:
-                pm.add_target_library_info(mod.triple)
-            pm.add_instruction_combining_pass()
-            pm.run(mod)
-            return mod
-
-        # Run with TLI should suppress transformation of exp2 -> ldexpf
-        mod = run(use_tli=True)
-        self.assertIn("call float @llvm.exp2.f32", str(mod))
-
-        # Run without TLI will enable the transformation
-        mod = run(use_tli=False)
-        self.assertNotIn("call float @llvm.exp2.f32", str(mod))
-        self.assertIn("call float @ldexpf", str(mod))
-
-    def test_instruction_namer_pass(self):
-        asm = asm_inlineasm3.format(triple=llvm.get_default_triple())
-        mod = llvm.parse_assembly(asm)
-
-        # Run instnamer pass
-        pm = llvm.ModulePassManager()
-        pm.add_instruction_namer_pass()
-        pm.run(mod)
-
-        # Test that unnamed instructions are now named
-        func = mod.get_function('foo')
-        first_block = next(func.blocks)
-        instructions = list(first_block.instructions)
-        self.assertEqual(instructions[0].name, 'i')
-        self.assertEqual(instructions[1].name, 'i2')
-
-
 class TestDylib(BaseTest):
 
     def test_bad_library(self):
@@ -2711,6 +2357,8 @@ class TestTypeParsing(BaseTest):
 
 
 class TestGlobalConstructors(TestMCJit):
+    @unittest.skipIf(platform.system() == "Darwin",
+                     "__cxa_atexit is broken on OSX in MCJIT")
     def test_global_ctors_dtors(self):
         # test issue #303
         # (https://github.com/numba/llvmlite/issues/303)
@@ -2822,19 +2470,19 @@ class TestObjectFile(BaseTest):
         obj_bin = target_machine.emit_object(mod)
         obj = llvm.ObjectFileRef.from_data(obj_bin)
         # Check that we have a text section, and that she has a name and data
-        has_text = False
+        has_text_and_data = False
         last_address = -1
         for s in obj.sections():
-            if s.is_text():
-                has_text = True
-                self.assertIsNotNone(s.name())
-                self.assertTrue(s.size() > 0)
-                self.assertTrue(len(s.data()) > 0)
-                self.assertIsNotNone(s.address())
-                self.assertTrue(last_address < s.address())
+            if (
+                s.is_text()
+                and len(s.data()) > 0
+                and s.address() is not None
+                and last_address < s.address()
+            ):
+                has_text_and_data = True
                 last_address = s.address()
                 break
-        self.assertTrue(has_text)
+        self.assertTrue(has_text_and_data)
 
     def test_add_object_file(self):
         target_machine = self.target_machine(jit=False)
@@ -2889,31 +2537,6 @@ class TestObjectFile(BaseTest):
                 self.assertEqual(s.data().hex(), issue_632_text)
 
 
-class TestTimePasses(BaseTest):
-    def test_reporting(self):
-        mp = llvm.create_module_pass_manager()
-
-        pmb = llvm.create_pass_manager_builder()
-        pmb.opt_level = 3
-        pmb.populate(mp)
-
-        try:
-            llvm.set_time_passes(True)
-            mp.run(self.module())
-            mp.run(self.module())
-            mp.run(self.module())
-        finally:
-            report = llvm.report_and_reset_timings()
-            llvm.set_time_passes(False)
-
-        self.assertIsInstance(report, str)
-        self.assertEqual(report.count("Pass execution timing report"), 1)
-
-    def test_empty_report(self):
-        # Returns empty str if no data is collected
-        self.assertFalse(llvm.report_and_reset_timings())
-
-
 class TestLLVMLockCallbacks(BaseTest):
     def test_lock_callbacks(self):
         events = []
@@ -2930,7 +2553,7 @@ class TestLLVMLockCallbacks(BaseTest):
         # Check: events are initially empty
         self.assertFalse(events)
         # Call LLVM functions
-        llvm.create_module_pass_manager()
+        llvm.create_new_module_pass_manager()
         # Check: there must be at least one acq and one rel
         self.assertIn("acq", events)
         self.assertIn("rel", events)
@@ -2966,13 +2589,11 @@ class TestPipelineTuningOptions(BaseTest):
             pto.size_level = i
             self.assertEqual(pto.size_level, i)
 
-    # // FIXME: Available from llvm16
-    # def test_inlining_threshold(self):
-    #     pto = self.pto()
-    #     with self.assertRaises(NotImplementedError):
-    #         pto.inlining_threshold
-    #     for i in (25, 80, 350):
-    #         pto.inlining_threshold = i
+    def test_inlining_threshold(self):
+        pto = self.pto()
+        self.assertIsInstance(pto.inlining_threshold, int)
+        for i in (25, 80, 350):
+            pto.inlining_threshold = i
 
     def test_loop_interleaving(self):
         pto = self.pto()
@@ -3058,6 +2679,56 @@ class TestPassBuilder(BaseTest, NewPassManagerMixin):
         fpm.run(self.module().get_function("sum"), pb)
         pb.close()
 
+    def test_time_passes(self):
+        """Test pass timing reports for O3 and O0 optimization levels"""
+        def run_with_timing(speed_level):
+            mod = self.module()
+            pb = self.pb(speed_level=speed_level, size_level=0)
+            pb.start_pass_timing()
+            mpm = pb.getModulePassManager()
+            mpm.run(mod, pb)
+            report = pb.finish_pass_timing()
+            pb.close()
+            return report
+
+        report_O3 = run_with_timing(3)
+        report_O0 = run_with_timing(0)
+
+        self.assertIsInstance(report_O3, str)
+        self.assertIsInstance(report_O0, str)
+        self.assertEqual(report_O3.count("Pass execution timing report"), 1)
+        self.assertEqual(report_O0.count("Pass execution timing report"), 1)
+
+    def test_empty_report(self):
+        mod = self.module()
+        pb = self.pb()
+        mpm = pb.getModulePassManager()
+        mpm.run(mod, pb)
+        pb.start_pass_timing()
+        report = pb.finish_pass_timing()
+        pb.close()
+        self.assertFalse(report)
+
+    def test_multiple_timers_error(self):
+        mod = self.module()
+        pb = self.pb()
+        pb.start_pass_timing()
+        mpm = pb.getModulePassManager()
+        mpm.run(mod, pb)
+        pb.finish_pass_timing()
+        with self.assertRaisesRegex(RuntimeError, "only be done once"):
+            pb.start_pass_timing()
+        pb.close()
+
+    def test_empty_report_error(self):
+        mod = self.module()
+        pb = self.pb()
+        mpm = pb.getModulePassManager()
+        mpm.run(mod, pb)
+        with self.assertRaisesRegex(RuntimeError, "not enabled"):
+            pb.finish_pass_timing()
+        pb.close()
+
 
 class TestNewModulePassManager(BaseTest, NewPassManagerMixin):
     def pm(self):
@@ -3118,13 +2789,66 @@ class TestNewModulePassManager(BaseTest, NewPassManagerMixin):
 
     def test_add_passes(self):
         mpm = self.pm()
+        mpm.add_argument_promotion_pass()
+        mpm.add_post_order_function_attributes_pass()
         mpm.add_verifier()
+        mpm.add_constant_merge_pass()
+        mpm.add_dead_arg_elimination_pass()
+        mpm.add_dot_call_graph_printer_pass()
+        mpm.add_always_inliner_pass()
+        mpm.add_rpo_function_attrs_pass()
+        mpm.add_global_dead_code_eliminate_pass()
+        mpm.add_global_opt_pass()
+        mpm.add_ipsccp_pass()
+        mpm.add_internalize_pass()
+        mpm.add_loop_extract_pass()
+        mpm.add_merge_functions_pass()
+        mpm.add_partial_inliner_pass()
+        mpm.add_strip_symbols_pass()
+        mpm.add_strip_dead_debug_info_pass()
+        mpm.add_strip_dead_prototype_pass()
+        mpm.add_strip_debug_declare_pass()
+        mpm.add_strip_non_debug_symbols_pass()
         mpm.add_aa_eval_pass()
         mpm.add_simplify_cfg_pass()
         mpm.add_loop_unroll_pass()
-        mpm.add_loop_rotate_pass()
         mpm.add_instruction_combine_pass()
         mpm.add_jump_threading_pass()
+        mpm.add_cfg_printer_pass()
+        mpm.add_cfg_only_printer_pass()
+        mpm.add_dom_printer_pass()
+        mpm.add_dom_only_printer_pass()
+        mpm.add_post_dom_printer_pass()
+        mpm.add_post_dom_only_printer_pass()
+        mpm.add_dom_viewer_pass()
+        mpm.add_dom_only_printer_pass()
+        mpm.add_post_dom_viewer_pass()
+        mpm.add_post_dom_only_viewer_pass()
+        mpm.add_lint_pass()
+        mpm.add_aggressive_dce_pass()
+        mpm.add_break_critical_edges_pass()
+        mpm.add_dead_store_elimination_pass()
+        mpm.add_dead_code_elimination_pass()
+        mpm.add_aggressive_instcombine_pass()
+        mpm.add_lcssa_pass()
+        mpm.add_new_gvn_pass()
+        mpm.add_loop_simplify_pass()
+        mpm.add_loop_unroll_and_jam_pass()
+        mpm.add_sccp_pass()
+        mpm.add_lower_atomic_pass()
+        mpm.add_lower_invoke_pass()
+        mpm.add_lower_switch_pass()
+        mpm.add_mem_copy_opt_pass()
+        mpm.add_unify_function_exit_nodes_pass()
+        mpm.add_reassociate_pass()
+        mpm.add_register_to_memory_pass()
+        mpm.add_sroa_pass()
+        mpm.add_sinking_pass()
+        mpm.add_tail_call_elimination_pass()
+        mpm.add_instruction_namer_pass()
+        mpm.add_loop_deletion_pass()
+        mpm.add_loop_strength_reduce_pass()
+        mpm.add_loop_rotate_pass()
         mpm.add_refprune_pass()
 
 
@@ -3198,11 +2922,229 @@ class TestNewFunctionPassManager(BaseTest, NewPassManagerMixin):
         fpm.add_aa_eval_pass()
         fpm.add_simplify_cfg_pass()
         fpm.add_loop_unroll_pass()
-        fpm.add_loop_rotate_pass()
         fpm.add_instruction_combine_pass()
         fpm.add_jump_threading_pass()
+        fpm.add_cfg_printer_pass()
+        fpm.add_cfg_only_printer_pass()
+        fpm.add_dom_printer_pass()
+        fpm.add_dom_only_printer_pass()
+        fpm.add_post_dom_printer_pass()
+        fpm.add_post_dom_only_printer_pass()
+        fpm.add_dom_viewer_pass()
+        fpm.add_dom_only_printer_pass()
+        fpm.add_post_dom_viewer_pass()
+        fpm.add_post_dom_only_viewer_pass()
+        fpm.add_lint_pass()
+        fpm.add_aggressive_dce_pass()
+        fpm.add_break_critical_edges_pass()
+        fpm.add_dead_store_elimination_pass()
+        fpm.add_dead_code_elimination_pass()
+        fpm.add_aggressive_instcombine_pass()
+        fpm.add_lcssa_pass()
+        fpm.add_new_gvn_pass()
+        fpm.add_loop_simplify_pass()
+        fpm.add_loop_unroll_and_jam_pass()
+        fpm.add_sccp_pass()
+        fpm.add_lower_atomic_pass()
+        fpm.add_lower_invoke_pass()
+        fpm.add_lower_switch_pass()
+        fpm.add_mem_copy_opt_pass()
+        fpm.add_unify_function_exit_nodes_pass()
+        fpm.add_reassociate_pass()
+        fpm.add_register_to_memory_pass()
+        fpm.add_sroa_pass()
+        fpm.add_sinking_pass()
+        fpm.add_tail_call_elimination_pass()
+        fpm.add_instruction_namer_pass()
+        fpm.add_loop_deletion_pass()
+        fpm.add_loop_strength_reduce_pass()
+        fpm.add_loop_rotate_pass()
         fpm.add_refprune_pass()
 
 
+@unittest.skipUnless(os.environ.get('LLVMLITE_DIST_TEST'),
+                     "Distribution-specific test")
+@needs_lief
+class TestBuild(TestCase):
+    # These tests are for use by the Numba project maintainers to check that
+    # package builds for which they are responsible are producing artifacts in
+    # the expected way. If you are a package maintainer and these tests are
+    # running, they shouldn't be by default. The only way they will run is if
+    # the environment variable LLVMLITE_DIST_TEST is set. The things they are
+    # checking are based on how the Numba project maintainers want to ship the
+    # packages, this may be entirely different to how other maintainers wish to
+    # ship. Basically, don't enable these tests unless you are sure they are
+    # suitable for your use case.
+    #
+    # The llvmlite DSO is the foundation of Numba's JIT compiler stack and is
+    # also used by other similar projects. It has to link against LLVM as that
+    # is what provides the tooling to do e.g. IR generation and JIT compilation.
+    # There are various options surrounding how to build LLVM and then how to
+    # link it into llvmlite. There have been many occurences of surprising
+    # linkages, symbol collisions and various other issues.
+    #
+    # The following tests are designed to try and test out some of the more
+    # common combinations of package type and linkage.
+    #
+    # NOTE: For Numba project maintainers on packaging formats and expected
+    # linkage. The following dictionaries capture the state of linkage as of
+    # llvmlite release 0.44. This is not an indication that it is correct, just
+    # that this is what is present in practice and clearly "works" to a large
+    # degree by virtue of having fixed the few reported issues. If you need to
+    # modify these dictionaries based on new information, that's fine, just make
+    # sure that it is an understood action opposed to just capturing what
+    # happened!
+
+    wheel_expected = {"linux": {"x86_64": set(["pthread",
+                                               "z",
+                                               "dl",
+                                               "m",
+                                               "gcc_s",
+                                               "c",
+                                               "rt",
+                                               "stdc++",
+                                               "ld-linux-x86-64",]),
+                                "aarch64":  set(["pthread",
+                                                 "z",
+                                                 "dl",
+                                                 "m",
+                                                 "gcc_s",
+                                                 "c",
+                                                 "rt",
+                                                 "stdc++",]),
+                                }, # end linux
+                      # NOTE: on windows, this includes a "capture what is
+                      # present and known to work and make sure it doesn"t
+                      # change" approach.
+                      "windows": {"amd64": set(["advapi32",
+                                                "kernel32",
+                                                "ntdll",
+                                                "msvcp140",
+                                                "vcruntime140",
+                                                "vcruntime140_1",
+                                                "api-ms-win-crt-convert-l1-1-0",
+                                                "api-ms-win-crt-environment-l1-1-0", # noqa: E501
+                                                "api-ms-win-crt-heap-l1-1-0",
+                                                "api-ms-win-crt-locale-l1-1-0",
+                                                "api-ms-win-crt-math-l1-1-0",
+                                                "api-ms-win-crt-runtime-l1-1-0",
+                                                "api-ms-win-crt-stdio-l1-1-0",
+                                                "api-ms-win-crt-string-l1-1-0",
+                                                "api-ms-win-crt-time-l1-1-0",
+                                                "api-ms-win-crt-utility-l1-1-0",
+                                                "shell32",  # this is delayed
+                                                "ole32",]), # also delayed
+                                  }, # end windows
+                      "darwin": {"x86_64": set(["llvmlite",
+                                                "system",
+                                                "z",
+                                                "corefoundation",
+                                                "c++",]),
+                                 "arm64": set(["llvmlite",
+                                               "system",
+                                               "z",
+                                               "c++",]),
+                                 },# end darwin
+                      } # end wheel_expected
+
+    conda_expected = {"linux": {"x86_64": set(["pthread",
+                                               "z",
+                                               "zstd",
+                                               "dl",
+                                               "m",
+                                               "gcc_s",
+                                               "c",
+                                               # "stdc++", conda has static c++
+                                               "ld-linux-x86-64",]),
+                                "aarch64":  set(["pthread",
+                                                 "z",
+                                                 "zstd",
+                                                 "dl",
+                                                 "m",
+                                                 "gcc_s",
+                                                 "c",
+                                                 # "stdc++", conda has static c++ # noqa: E501
+                                                 "ld-linux-aarch64",]),
+                                }, # end linux
+                      # NOTE: on windows, this includes a "capture what is
+                      # present and known to work and make sure it doesn"t
+                      # change" approach.
+                      "windows": {"amd64": set(["z",
+                                                "zstd",
+                                                "advapi32",
+                                                "kernel32",
+                                                "ntdll",
+                                                "msvcp140",
+                                                "vcruntime140",
+                                                "vcruntime140_1",
+                                                "api-ms-win-crt-convert-l1-1-0",
+                                                "api-ms-win-crt-environment-l1-1-0", # noqa: E501
+                                                "api-ms-win-crt-heap-l1-1-0",
+                                                "api-ms-win-crt-locale-l1-1-0",
+                                                "api-ms-win-crt-math-l1-1-0",
+                                                "api-ms-win-crt-runtime-l1-1-0",
+                                                "api-ms-win-crt-stdio-l1-1-0",
+                                                "api-ms-win-crt-string-l1-1-0",
+                                                "api-ms-win-crt-time-l1-1-0",
+                                                "api-ms-win-crt-utility-l1-1-0",
+                                                "shell32",  # this is delayed
+                                                "ole32",]), # also delayed
+                                  }, # end windows
+                      "darwin": {"x86_64": set(["llvmlite",
+                                                "system",
+                                                "z",
+                                                "zstd",
+                                                "corefoundation",
+                                                "c++",]),
+                                 "arm64": set(["llvmlite",
+                                               "system",
+                                               "z",
+                                               "zstd",
+                                               "c++",]),
+                                 },# end darwin
+                      } # end wheel_expected
+
+    def check_linkage(self, info, package_type):
+        machine = platform.machine().lower()
+        os_name = platform.system().lower()
+
+        if package_type == "wheel":
+            expected = self.wheel_expected[os_name][machine]
+        elif package_type == "conda":
+            expected = self.conda_expected[os_name][machine]
+        else:
+            raise ValueError(f"Unexpected package type: {package_type}")
+
+        got = set(info["canonicalised_linked_libraries"])
+
+        try:
+            self.assertEqual(expected, got)
+        except AssertionError as e:
+            msg = ("Unexpected linkage encountered for libllvmlite:\n"
+                   f"Expected: {sorted(expected)}\n"
+                   f"     Got: {sorted(got)}\n\n"
+                   f"Difference: {set.symmetric_difference(expected, got)}\n"
+                   f"Only in Expected: {set.difference(expected, got)}\n"
+                   f"Only in Got: {set.difference(got, expected)}\n")
+            raise AssertionError(msg) from e
+
+    @is_wheel_package
+    def test_wheel_build(self):
+        info = llvm.config.get_sysinfo()
+        self.assertEqual(info['llvm_linkage_type'], "static")
+        self.assertEqual(info['llvm_assertions_state'], "on")
+        self.check_linkage(info, "wheel")
+
+    @is_conda_package
+    def test_conda_build(self):
+        info = llvm.config.get_sysinfo()
+        self.assertEqual(info['llvm_linkage_type'], "static")
+        self.assertEqual(info['llvm_assertions_state'], "on")
+
+        self.check_linkage(info, "conda")
+        if platform.system().lower() == "linux":
+            self.assertEqual(info['libstdcxx_linkage_type'], "static")
+
+
 if __name__ == "__main__":
     unittest.main()