numba-cuda 0.23.0__cp313-cp313-win_amd64.whl → 0.24.0__cp313-cp313-win_amd64.whl

numba_cuda/numba/cuda/core/interpreter.py

@@ -27,7 +27,7 @@ from numba.cuda.core.unsafe import eh
 from numba.cuda.cpython.unsafe.tuple import unpack_single_tuple
 
 
-if PYVERSION in ((3, 12), (3, 13)):
+if PYVERSION in ((3, 12), (3, 13), (3, 14)):
     # Operands for CALL_INTRINSIC_1
     from numba.cuda.core.byteflow import CALL_INTRINSIC_1_Operand as ci1op
 elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
@@ -774,7 +774,7 @@ def peep_hole_list_to_tuple(func_ir):
     _DEBUG = False
 
     # For all blocks
-    for offset, blk in func_ir.blocks.items():
+    for blk in func_ir.blocks.values():
         # keep doing the peephole rewrite until nothing is left that matches
         while True:
             # first try and find a matching region
@@ -1003,11 +1003,12 @@ def peep_hole_delete_with_exit(func_ir):
                 if isinstance(stmt, ir.assign_types):
                     dead_vars.add(stmt.target)
 
-        new_body = []
-        for stmt in blk.body:
+        new_body = [
+            stmt
+            for stmt in blk.body
             # Skip any statements that uses anyone of the dead variable.
-            if not (set(stmt.list_vars()) & dead_vars):
-                new_body.append(stmt)
+            if not (set(stmt.list_vars()) & dead_vars)
+        ]
         blk.body.clear()
         blk.body.extend(new_body)
 
@@ -1323,8 +1324,7 @@ def _build_new_build_map(func_ir, name, old_body, old_lineno, new_items):
     if len(literal_keys) == len(new_items):
         # All keys must be literals to have any literal values.
         literal_value = {x: y for x, y in zip(literal_keys, values)}
-        for i, k in enumerate(literal_keys):
-            value_indexes[k] = i
+        value_indexes.update((k, i) for i, k in enumerate(literal_keys))
     else:
         literal_value = None
 
@@ -1390,14 +1390,14 @@ class Interpreter(object):
         self.current_block = None
         self.current_block_offset = None
         last_active_offset = 0
-        for _, inst_blocks in self.cfa.blocks.items():
+        for inst_blocks in self.cfa.blocks.values():
             if inst_blocks.body:
                 last_active_offset = max(
                     last_active_offset, max(inst_blocks.body)
                 )
         self.last_active_offset = last_active_offset
 
-        if PYVERSION in ((3, 12), (3, 13)):
+        if PYVERSION in ((3, 12), (3, 13), (3, 14)):
             self.active_exception_entries = tuple(
                 [
                     entry
@@ -1417,7 +1417,7 @@ class Interpreter(object):
         # Interpret loop
         for inst, kws in self._iter_inst():
             self._dispatch(inst, kws)
-        if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+        if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
             # Insert end of try markers
             self._end_try_blocks()
         elif PYVERSION in (
@@ -1445,12 +1445,12 @@ class Interpreter(object):
         # post process the IR to rewrite opcodes/byte sequences that are too
         # involved to risk handling as part of direct interpretation
         peepholes = []
-        if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+        if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
             peepholes.append(peep_hole_split_at_pop_block)
-        if PYVERSION in ((3, 9), (3, 10), (3, 11), (3, 12), (3, 13)):
+        if PYVERSION in ((3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (3, 14)):
             peepholes.append(peep_hole_list_to_tuple)
         peepholes.append(peep_hole_delete_with_exit)
-        if PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+        if PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13), (3, 14)):
             # peep_hole_call_function_ex_to_call_function_kw
             # depends on peep_hole_list_to_tuple converting
             # any large number of arguments from a list to a
@@ -1483,7 +1483,7 @@ class Interpreter(object):
 
         See also: _insert_try_block_end
         """
-        assert PYVERSION in ((3, 11), (3, 12), (3, 13))
+        assert PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14))
         graph = self.cfa.graph
         for offset, block in self.blocks.items():
             # Get current blockstack
@@ -1591,7 +1591,7 @@ class Interpreter(object):
         self.dfainfo = self.dfa.infos[self.current_block_offset]
         self.assigner = Assigner()
         # Check out-of-scope syntactic-block
-        if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+        if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
             # This is recreating pre-3.11 code structure
             while self.syntax_blocks:
                 if offset >= self.syntax_blocks[-1].exit:
@@ -1778,7 +1778,7 @@ class Interpreter(object):
                 val = self.get(varname)
             except ir.NotDefinedError:
                 # Hack to make sure exception variables are defined
-                assert PYVERSION in ((3, 11), (3, 12), (3, 13)), (
+                assert PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)), (
                     "unexpected missing definition"
                 )
                 val = ir.Const(value=None, loc=self.loc)
@@ -1838,7 +1838,7 @@ class Interpreter(object):
         if self._DEBUG_PRINT:
             print(inst)
         assert self.current_block is not None
-        if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+        if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
             if self.syntax_blocks:
                 top = self.syntax_blocks[-1]
                 if isinstance(top, ir.with_types):
@@ -1929,6 +1929,14 @@ class Interpreter(object):
     def op_NOP(self, inst):
         pass
 
+    if PYVERSION in ((3, 14),):
+        # New in 3.14
+        op_NOT_TAKEN = op_NOP
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+        pass
+    else:
+        raise NotImplementedError(PYVERSION)
+
     def op_RESUME(self, inst):
         pass
 
@@ -2028,7 +2036,7 @@ class Interpreter(object):
             )
         self.store(value=sliceinst, name=res)
 
-    if PYVERSION in ((3, 12), (3, 13)):
+    if PYVERSION in ((3, 12), (3, 13), (3, 14)):
 
         def op_BINARY_SLICE(
             self, inst, start, end, container, res, slicevar, temp_res
@@ -2050,7 +2058,7 @@ class Interpreter(object):
     else:
         raise NotImplementedError(PYVERSION)
 
-    if PYVERSION in ((3, 12), (3, 13)):
+    if PYVERSION in ((3, 12), (3, 13), (3, 14)):
 
         def op_STORE_SLICE(
             self, inst, start, end, container, value, res, slicevar
@@ -2320,7 +2328,7 @@ class Interpreter(object):
         srcname = self.code_locals[inst.arg]
         self.store(value=self.get(srcname), name=res)
 
-    if PYVERSION in ((3, 13),):
+    if PYVERSION in ((3, 13), (3, 14)):
 
         def op_LOAD_FAST(self, inst, res, as_load_deref=False):
             if as_load_deref:
@@ -2331,7 +2339,7 @@ class Interpreter(object):
     else:
         op_LOAD_FAST = _op_LOAD_FAST
 
-    if PYVERSION in ((3, 13),):
+    if PYVERSION in ((3, 13), (3, 14)):
 
         def op_LOAD_FAST_LOAD_FAST(self, inst, res1, res2):
             oparg = inst.arg
@@ -2369,7 +2377,7 @@ class Interpreter(object):
     else:
         raise NotImplementedError(PYVERSION)
 
-    if PYVERSION in ((3, 12), (3, 13)):
+    if PYVERSION in ((3, 12), (3, 13), (3, 14)):
         op_LOAD_FAST_CHECK = op_LOAD_FAST
 
         def op_LOAD_FAST_AND_CLEAR(self, inst, res):
@@ -2387,6 +2395,16 @@ class Interpreter(object):
     else:
         raise NotImplementedError(PYVERSION)
 
+    if PYVERSION in ((3, 14),):
+        # New in 3.14.
+        op_LOAD_FAST_BORROW = op_LOAD_FAST
+        op_LOAD_FAST_BORROW_LOAD_FAST_BORROW = op_LOAD_FAST_LOAD_FAST
+
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+        pass
+    else:
+        raise NotImplementedError(PYVERSION)
+
     def op_STORE_FAST(self, inst, value):
         dstname = self.code_locals[inst.arg]
         value = self.get(value)
@@ -2420,7 +2438,7 @@ class Interpreter(object):
 
     def op_LOAD_ATTR(self, inst, item, res):
         item = self.get(item)
-        if PYVERSION in ((3, 12), (3, 13)):
+        if PYVERSION in ((3, 12), (3, 13), (3, 14)):
             attr = self.code_names[inst.arg >> 1]
         elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
             attr = self.code_names[inst.arg]
@@ -2430,28 +2448,85 @@ class Interpreter(object):
         self.store(getattr, res)
 
     def op_LOAD_CONST(self, inst, res):
-        value = self.code_consts[inst.arg]
-        if isinstance(value, tuple):
+        # New in 3.14: slice is loaded via LOAD_CONST. The value is the
+        # slice object itself, so we get the start, stop and step from it
+        # directly and then proceed with the code in `BUILD_SLICE`. It may also
+        # be a tuple containing a slice, so we need to account for that too.
+        def process_slice(value):
+            start = self.store(
+                ir.Const(value.start, loc=self.loc),
+                name=f"$const_{value.start}",
+                redefine=True,
+            )
+            stop = self.store(
+                ir.Const(value.stop, loc=self.loc),
+                name=f"$const_{value.stop}",
+                redefine=True,
+            )
+
+            slicevar = self.store(
+                value=ir.Global("slice", slice, loc=self.loc),
+                name="$const_slice",
+                redefine=True,
+            )
+
+            if value.step is None:
+                params = (start, stop)
+            else:
+                step = self.store(
+                    ir.Const(value.step, loc=self.loc),
+                    name=f"$const_{value.step}",
+                    redefine=True,
+                )
+                params = (start, stop, step)
+
+            return ir.Expr.call(slicevar, params, (), loc=self.loc)
+
+        def process_args(value):
             st = []
             for x in value:
-                nm = "$const_%s" % str(x)
-                val_const = ir.Const(x, loc=self.loc)
-                target = self.store(val_const, name=nm, redefine=True)
-                st.append(target)
-            const = ir.Expr.build_tuple(st, loc=self.loc)
+                if isinstance(x, slice):
+                    st.append(
+                        self.store(
+                            process_slice(x),
+                            name="$const_my_slice",
+                            redefine=True,
+                        )
+                    )
+                else:
+                    st.append(
+                        self.store(
+                            ir.Const(x, loc=self.loc),
+                            name=f"$const_{x}",
+                            redefine=True,
+                        )
+                    )
+            return st
+
+        value = self.code_consts[inst.arg]
+
+        if isinstance(value, tuple):
+            const = ir.Expr.build_tuple(process_args(value), loc=self.loc)
         elif isinstance(value, frozenset):
-            st = []
-            for x in value:
-                nm = "$const_%s" % str(x)
-                val_const = ir.Const(x, loc=self.loc)
-                target = self.store(val_const, name=nm, redefine=True)
-                st.append(target)
-            const = ir.Expr.build_set(st, loc=self.loc)
+            const = ir.Expr.build_set(process_args(value), loc=self.loc)
+        elif isinstance(value, slice):
+            const = process_slice(value)
         else:
             const = ir.Const(value, loc=self.loc)
         self.store(const, res)
 
-    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+    if PYVERSION in ((3, 14),):
+        # New in 3.14
+        def op_LOAD_SMALL_INT(self, inst, res):
+            value = inst.arg
+            const = ir.Const(value, loc=self.loc)
+            self.store(const, res)
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+        pass
+    else:
+        raise NotImplementedError(PYVERSION)
+
+    if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
 
         def op_LOAD_GLOBAL(self, inst, idx, res):
             name = self.code_names[idx]
@@ -2474,7 +2549,7 @@ class Interpreter(object):
     def op_COPY_FREE_VARS(self, inst):
         pass
 
-    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
 
         def op_LOAD_DEREF(self, inst, res):
             name = self.func_id.func.__code__._varname_from_oparg(inst.arg)
@@ -2508,12 +2583,12 @@ class Interpreter(object):
     else:
         raise NotImplementedError(PYVERSION)
 
-    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
 
         def op_MAKE_CELL(self, inst):
             pass  # ignored bytecode
 
-    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
 
         def op_STORE_DEREF(self, inst, value):
             name = self.func_id.func.__code__._varname_from_oparg(inst.arg)
@@ -2561,39 +2636,46 @@ class Interpreter(object):
         exit_fn_obj = ir.Const(None, loc=self.loc)
         self.store(value=exit_fn_obj, name=exitfn)
 
-    def op_BEFORE_WITH(self, inst, contextmanager, exitfn, end):
-        assert self.blocks[inst.offset] is self.current_block
-        if PYVERSION in ((3, 12), (3, 13)):
-            # Python 3.12 hack for handling nested with blocks
-            if end > self.last_active_offset:
-                # Use exception entries to figure out end of syntax block
-                end = max(
-                    [
-                        ex.end
-                        for ex in self.active_exception_entries
-                        if ex.target == end
-                    ]
+    if PYVERSION in ((3, 14),):
+        # Replaced by LOAD_SPECIAL in 3.14.
+        pass
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+
+        def op_BEFORE_WITH(self, inst, contextmanager, exitfn, end):
+            assert self.blocks[inst.offset] is self.current_block
+            if PYVERSION in ((3, 12), (3, 13)):
+                # Python 3.12 hack for handling nested with blocks
+                if end > self.last_active_offset:
+                    # Use exception entries to figure out end of syntax block
+                    end = max(
+                        [
+                            ex.end
+                            for ex in self.active_exception_entries
+                            if ex.target == end
+                        ]
+                    )
+            elif PYVERSION in ((3, 10), (3, 11)):
+                pass
+            else:
+                raise NotImplementedError(PYVERSION)
+            # Handle with
+            wth = ir.With(inst.offset, exit=end)
+            self.syntax_blocks.append(wth)
+            ctxmgr = self.get(contextmanager)
+            self.current_block.append(
+                ir.EnterWith(
+                    contextmanager=ctxmgr,
+                    begin=inst.offset,
+                    end=end,
+                    loc=self.loc,
                 )
-        elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
-            pass
-        else:
-            raise NotImplementedError(PYVERSION)
-        # Handle with
-        wth = ir.With(inst.offset, exit=end)
-        self.syntax_blocks.append(wth)
-        ctxmgr = self.get(contextmanager)
-        self.current_block.append(
-            ir.EnterWith(
-                contextmanager=ctxmgr,
-                begin=inst.offset,
-                end=end,
-                loc=self.loc,
             )
-        )
 
-        # Store exit function
-        exit_fn_obj = ir.Const(None, loc=self.loc)
-        self.store(value=exit_fn_obj, name=exitfn)
+            # Store exit function
+            exit_fn_obj = ir.Const(None, loc=self.loc)
+            self.store(value=exit_fn_obj, name=exitfn)
+    else:
+        raise NotImplementedError(PYVERSION)
 
     def op_SETUP_FINALLY(self, inst):
         # Removed since python3.11
@@ -2632,7 +2714,7 @@ class Interpreter(object):
         expr = ir.Expr.call(func, args, kwargs, loc=self.loc)
         self.store(expr, res)
 
-    if PYVERSION in ((3, 13),):
+    if PYVERSION in ((3, 13), (3, 14)):
 
         def op_CALL_KW(self, inst, func, args, kw_names, res):
             func = self.get(func)
@@ -2807,9 +2889,7 @@ class Interpreter(object):
         # store the index of the actual used value for a given key, this is
         # used when lowering to pull the right value out into the tuple repr
         # of a mixed value type dictionary.
-        value_indexes = {}
-        for i, k in enumerate(keytup):
-            value_indexes[k] = i
+        value_indexes = {k: i for i, k in enumerate(keytup)}
 
         expr = ir.Expr.build_map(
             items=items,
@@ -2852,11 +2932,18 @@ class Interpreter(object):
         )
         self.current_block.append(br)
 
-    def op_BINARY_SUBSCR(self, inst, target, index, res):
-        index = self.get(index)
-        target = self.get(target)
-        expr = ir.Expr.getitem(target, index=index, loc=self.loc)
-        self.store(expr, res)
+    if PYVERSION in ((3, 14),):
+        # Removed in 3.14 -- replaced with BINARY_OP and []
+        pass
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+
+        def op_BINARY_SUBSCR(self, inst, target, index, res):
+            index = self.get(index)
+            target = self.get(target)
+            expr = ir.Expr.getitem(target, index=index, loc=self.loc)
+            self.store(expr, res)
+    else:
+        raise NotImplementedError(PYVERSION)
 
     def op_STORE_SUBSCR(self, inst, target, index, value):
         index = self.get(index)
@@ -2889,6 +2976,14 @@ class Interpreter(object):
         )
         self.store(expr, res)
 
+    def op_SET_ADD(self, inst, value, target, addvar, res):
+        value = self.get(value)
+        target = self.get(target)
+        addattr = ir.Expr.getattr(target, "add", loc=self.loc)
+        self.store(value=addattr, name=addvar)
+        addinst = ir.Expr.call(self.get(addvar), (value,), (), loc=self.loc)
+        self.store(value=addinst, name=res)
+
     def op_SET_UPDATE(self, inst, target, value, updatevar, res):
         target = self.get(target)
         value = self.get(value)
@@ -2948,12 +3043,10 @@ class Interpreter(object):
             literal_dict = {
                 x: _UNKNOWN_VALUE(y[1]) for x, y in zip(literal_keys, got_items)
             }
-            for i, k in enumerate(literal_keys):
-                value_indexes[k] = i
+            value_indexes.update((k, i) for i, k in enumerate(literal_keys))
         else:
             literal_dict = {x: y for x, y in zip(literal_keys, literal_values)}
-            for i, k in enumerate(literal_keys):
-                value_indexes[k] = i
+            value_indexes.update((k, i) for i, k in enumerate(literal_keys))
 
         expr = ir.Expr.build_map(
             items=got_items,
@@ -3009,7 +3102,13 @@ class Interpreter(object):
         self.store(expr, res)
 
     def op_BINARY_OP(self, inst, op, lhs, rhs, res):
-        if "=" in op:
+        if op == "[]":
+            # Special case 3.14 -- body of BINARY_SUBSCR now here
+            lhs = self.get(lhs)
+            rhs = self.get(rhs)
+            expr = ir.Expr.getitem(lhs, index=rhs, loc=self.loc)
+            self.store(expr, res)
+        elif "=" in op:
             self._inplace_binop(op[:-1], lhs, rhs, res)
         else:
             self._binop(op, lhs, rhs, res)
@@ -3126,7 +3225,7 @@ class Interpreter(object):
         ret = ir.Return(self.get(castval), loc=self.loc)
         self.current_block.append(ret)
 
-    if PYVERSION in ((3, 12), (3, 13)):
+    if PYVERSION in ((3, 12), (3, 13), (3, 14)):
 
         def op_RETURN_CONST(self, inst, retval, castval):
             value = self.code_consts[inst.arg]
@@ -3140,7 +3239,7 @@ class Interpreter(object):
     else:
         raise NotImplementedError(PYVERSION)
 
-    if PYVERSION in ((3, 13),):
+    if PYVERSION in ((3, 13), (3, 14)):
 
         def op_TO_BOOL(self, inst, val, res):
             self.store(self.get(val), res)  # TODO: just a lazy hack
@@ -3151,7 +3250,7 @@ class Interpreter(object):
         raise NotImplementedError(PYVERSION)
 
     def op_COMPARE_OP(self, inst, lhs, rhs, res):
-        if PYVERSION in ((3, 13),):
+        if PYVERSION in ((3, 13), (3, 14)):
             op = dis.cmp_op[inst.arg >> 5]
             # TODO: fifth lowest bit now indicates a forced version to bool.
         elif PYVERSION in ((3, 12),):
@@ -3280,7 +3379,7 @@ class Interpreter(object):
     def op_POP_JUMP_FORWARD_IF_NOT_NONE(self, inst, pred):
         self._jump_if_none(inst, pred, False)
 
-    if PYVERSION in ((3, 12), (3, 13)):
+    if PYVERSION in ((3, 12), (3, 13), (3, 14)):
 
         def op_POP_JUMP_IF_NONE(self, inst, pred):
             self._jump_if_none(inst, pred, True)
@@ -3439,7 +3538,7 @@ class Interpreter(object):
             inst, name, code, closure, annotations, kwdefaults, defaults, res
         )
 
-    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
 
         def op_LOAD_CLOSURE(self, inst, res):
             name = self.func_id.func.__code__._varname_from_oparg(inst.arg)
@@ -3581,9 +3680,16 @@ class Interpreter(object):
         )
         self.store(value=appendinst, name=res)
 
-    def op_LOAD_ASSERTION_ERROR(self, inst, res):
-        gv_fn = ir.Global("AssertionError", AssertionError, loc=self.loc)
-        self.store(value=gv_fn, name=res)
+    if PYVERSION in ((3, 14),):
+        # Removed in 3.14
+        pass
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+
+        def op_LOAD_ASSERTION_ERROR(self, inst, res):
+            gv_fn = ir.Global("AssertionError", AssertionError, loc=self.loc)
+            self.store(value=gv_fn, name=res)
+    else:
+        raise NotImplementedError(PYVERSION)
 
     # NOTE: The LOAD_METHOD opcode is implemented as a LOAD_ATTR for ease,
     # however this means a new object (the bound-method instance) could be
@@ -3599,7 +3705,7 @@ class Interpreter(object):
     def op_CALL_METHOD(self, *args, **kws):
         self.op_CALL_FUNCTION(*args, **kws)
 
-    if PYVERSION in ((3, 12), (3, 13)):
+    if PYVERSION in ((3, 12), (3, 13), (3, 14)):
 
         def op_CALL_INTRINSIC_1(self, inst, operand, **kwargs):
             if operand == ci1op.INTRINSIC_STOPITERATION_ERROR:
@@ -3621,8 +3727,61 @@ class Interpreter(object):
     else:
         raise NotImplementedError(PYVERSION)
 
+    if PYVERSION in ((3, 14),):
+        # New in 3.14, replaces BEFORE_WITH.
+        def op_LOAD_SPECIAL(self, inst, contextmanager, exit_method, block_end):
+            assert self.blocks[inst.offset] is self.current_block
+
+            # Python 3.12 hack for handling nested with blocks
+            if block_end > self.last_active_offset:
+                # Use exception entries to figure out end of syntax block
+                block_end = max(
+                    [
+                        ex.end
+                        for ex in self.active_exception_entries
+                        if ex.target == block_end
+                    ]
+                )
+
+            # Handle with
+            wth = ir.With(inst.offset, exit=block_end)
+            self.syntax_blocks.append(wth)
+            ctxmgr = self.get(contextmanager)
+            self.current_block.append(
+                ir.EnterWith(
+                    contextmanager=ctxmgr,
+                    begin=inst.offset,
+                    end=block_end,
+                    loc=self.loc,
+                )
+            )
+
+            # Store exit function
+            exit_fn_obj = ir.Const(None, loc=self.loc)
+            self.store(value=exit_fn_obj, name=exit_method)
+
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+        pass
+    else:
+        raise NotImplementedError(PYVERSION)
+
+    if PYVERSION in ((3, 14),):
+
+        def op_LOAD_COMMON_CONSTANT(self, inst, res, idx):
+            if isinstance(dis._common_constants[idx], AssertionError):
+                gv_fn = ir.Global(
+                    "AssertionError", AssertionError, loc=self.loc
+                )
+                self.store(value=gv_fn, name=res)
+            else:
+                raise NotImplementedError
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+        pass
+    else:
+        raise NotImplementedError(PYVERSION)
+
 
-if PYVERSION in ((3, 12), (3, 13)):
+if PYVERSION in ((3, 12), (3, 13), (3, 14)):
 
     class INTRINSIC_STOPITERATION_ERROR(AssertionError):
         pass

numba_cuda/numba/cuda/core/ir_utils.py

@@ -389,10 +389,7 @@ def get_name_var_table(blocks):
 def replace_var_names(blocks, namedict):
     """replace variables (ir.Var to ir.Var) from dictionary (name -> name)"""
     # remove identity values to avoid infinite loop
-    new_namedict = {}
-    for l, r in namedict.items():
-        if l != r:
-            new_namedict[l] = r
+    new_namedict = {l: r for l, r in namedict.items() if l != r}
 
     def replace_name(var, namedict):
         assert isinstance(var, ir.var_types)
@@ -415,10 +412,7 @@ def replace_var_callback(var, vardict):
 def replace_vars(blocks, vardict):
     """replace variables (ir.Var to ir.Var) from dictionary (name -> ir.Var)"""
     # remove identity values to avoid infinite loop
-    new_vardict = {}
-    for l, r in vardict.items():
-        if l != r.name:
-            new_vardict[l] = r
+    new_vardict = {l: r for l, r in vardict.items() if l != r.name}
     visit_vars(blocks, replace_var_callback, new_vardict)
 
 
@@ -591,11 +585,9 @@ def flatten_labels(blocks):
 def remove_dels(blocks):
     """remove ir.Del nodes"""
     for block in blocks.values():
-        new_body = []
-        for stmt in block.body:
-            if not isinstance(stmt, ir.del_types):
-                new_body.append(stmt)
-        block.body = new_body
+        block.body = [
+            stmt for stmt in block.body if not isinstance(stmt, ir.del_types)
+        ]
     return
 
 
@@ -1076,7 +1068,7 @@ def init_copy_propagate_data(blocks, entry, typemap):
     gen_copies, extra_kill = get_block_copies(blocks, typemap)
     # set of all program copies
     all_copies = set()
-    for l, s in gen_copies.items():
+    for l in gen_copies.keys():
         all_copies |= gen_copies[l]
     kill_copies = {}
     for label, gen_set in gen_copies.items():
@@ -1122,8 +1114,7 @@ def get_block_copies(blocks, typemap):
             for T, f in copy_propagate_extensions.items():
                 if isinstance(stmt, T):
                     gen_set, kill_set = f(stmt, typemap)
-                    for lhs, rhs in gen_set:
-                        assign_dict[lhs] = rhs
+                    assign_dict.update(gen_set)
                     # if a=b is in dict and b is killed, a is also killed
                     new_assign_dict = {}
                     for l, r in assign_dict.items():
@@ -1933,7 +1924,7 @@ def compile_to_numba_ir(
     # rename all variables to avoid conflict
     var_table = get_name_var_table(f_ir.blocks)
     new_var_dict = {}
-    for name, var in var_table.items():
+    for name in var_table.keys():
         new_var_dict[name] = mk_unique_var(name)
     replace_var_names(f_ir.blocks, new_var_dict)