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

numba_cuda/numba/cuda/core/byteflow.py

@@ -34,7 +34,7 @@ _NO_RAISE_OPS = frozenset(
     }
 )
 
-if PYVERSION in ((3, 12), (3, 13)):
+if PYVERSION in ((3, 12), (3, 13), (3, 14)):
     from enum import Enum
 
     # Operands for CALL_INTRINSIC_1
@@ -161,7 +161,7 @@ class Flow(object):
             self.block_infos[state.pc_initial] = si = adapt_state_infos(state)
             _logger.debug("block_infos %s:\n%s", state, si)
 
-    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
 
         def _run_handle_exception(self, runner, state):
             if not state.in_with() and (
@@ -324,20 +324,29 @@ class Flow(object):
         else:
             return False
 
-    def _guard_with_as(self, state):
-        """Checks if the next instruction after a SETUP_WITH is something other
-        than a POP_TOP, if it is something else it'll be some sort of store
-        which is not supported (this corresponds to `with CTXMGR as VAR(S)`)."""
-        current_inst = state.get_inst()
-        if current_inst.opname in {"SETUP_WITH", "BEFORE_WITH"}:
-            next_op = self._bytecode[current_inst.next].opname
-            if next_op != "POP_TOP":
-                msg = (
-                    "The 'with (context manager) as "
-                    "(variable):' construct is not "
-                    "supported."
-                )
-                raise UnsupportedBytecodeError(msg)
+    if PYVERSION in ((3, 14),):
+
+        def _guard_with_as(self, state):
+            # Handled as part of `LOAD_SPECIAL` as of 3.14.
+            pass
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+
+        def _guard_with_as(self, state):
+            """Checks if the next instruction after a SETUP_WITH is something
+            other than a POP_TOP, if it is something else it'll be some sort of
+            store which is not supported (this corresponds to `with CTXMGR as
+            VAR(S)`)."""
+            current_inst = state.get_inst()
+            if current_inst.opname in {"SETUP_WITH", "BEFORE_WITH"}:
+                next_op = self._bytecode[current_inst.next].opname
+                if next_op != "POP_TOP":
+                    msg = (
+                        "The 'with (context manager) as (variable):' "
+                        "construct is not supported."
+                    )
+                    raise UnsupportedBytecodeError(msg)
+    else:
+        raise NotImplementedError(PYVERSION)
 
 
 def _is_null_temp_reg(reg):
@@ -356,7 +365,7 @@ class TraceRunner(object):
         return Loc(self.debug_filename, lineno)
 
     def dispatch(self, state):
-        if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+        if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
             if state._blockstack:
                 state: State
                 while state._blockstack:
@@ -409,6 +418,14 @@ class TraceRunner(object):
     def op_NOP(self, state, inst):
         state.append(inst)
 
+    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, state, inst):
         state.append(inst)
 
@@ -435,15 +452,18 @@ class TraceRunner(object):
         state.push(state.make_temp())
         state.append(inst)
 
-    if PYVERSION in ((3, 13),):
+    if PYVERSION in ((3, 13), (3, 14)):
 
         def op_FORMAT_SIMPLE(self, state, inst):
-            assert PYVERSION == (3, 13)
             value = state.pop()
             strvar = state.make_temp()
             res = state.make_temp()
             state.append(inst, value=value, res=res, strvar=strvar)
             state.push(res)
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+        pass
+    else:
+        raise NotImplementedError(PYVERSION)
 
     def op_FORMAT_VALUE(self, state, inst):
         """
@@ -484,18 +504,27 @@ class TraceRunner(object):
     def op_POP_TOP(self, state, inst):
         state.pop()
 
-    if PYVERSION in ((3, 13),):
+    if PYVERSION in ((3, 14),):
+        # New in 3.14
+        op_POP_ITER = op_POP_TOP
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+        pass
+    else:
+        raise NotImplementedError(PYVERSION)
+
+    if PYVERSION in ((3, 13), (3, 14)):
 
         def op_TO_BOOL(self, state, inst):
             res = state.make_temp()
             tos = state.pop()
             state.append(inst, val=tos, res=res)
             state.push(res)
-
-    elif PYVERSION < (3, 13):
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
         pass
+    else:
+        raise NotImplementedError(PYVERSION)
 
-    if PYVERSION in ((3, 13),):
+    if PYVERSION in ((3, 13), (3, 14)):
 
         def op_LOAD_GLOBAL(self, state, inst):
             # Ordering of the global value and NULL is swapped in Py3.13
@@ -545,10 +574,22 @@ class TraceRunner(object):
         state.push(res)
         state.append(inst, res=res)
 
+    if PYVERSION in ((3, 14),):
+        # New in 3.14
+        def op_LOAD_SMALL_INT(self, state, inst):
+            assert 0 <= inst.arg < 256
+            res = state.make_temp("const") + f".{inst.arg}"
+            state.push(res)
+            state.append(inst, res=res)
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+        pass
+    else:
+        raise NotImplementedError(PYVERSION)
+
     def op_LOAD_ATTR(self, state, inst):
         item = state.pop()
         res = state.make_temp()
-        if PYVERSION in ((3, 13),):
+        if PYVERSION in ((3, 13), (3, 14)):
             state.push(res)  # the attr
             if inst.arg & 1:
                 state.push(state.make_null())
@@ -563,8 +604,7 @@ class TraceRunner(object):
         state.append(inst, item=item, res=res)
 
     def op_LOAD_FAST(self, state, inst):
-        assert PYVERSION <= (3, 13)
-        if PYVERSION in ((3, 13),):
+        if PYVERSION in ((3, 13), (3, 14)):
             try:
                 name = state.get_varname(inst)
             except IndexError:  # oparg is out of range
@@ -583,13 +623,15 @@ class TraceRunner(object):
                 state.append(inst, res=res, as_load_deref=True)
                 state.push(res)
                 return
-        else:
+        elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
             name = state.get_varname(inst)
+        else:
+            raise NotImplementedError(PYVERSION)
         res = state.make_temp(name)
         state.append(inst, res=res)
         state.push(res)
 
-    if PYVERSION in ((3, 13),):
+    if PYVERSION in ((3, 13), (3, 14)):
 
         def op_LOAD_FAST_LOAD_FAST(self, state, inst):
             oparg = inst.arg
@@ -623,7 +665,7 @@ class TraceRunner(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
         op_LOAD_FAST_AND_CLEAR = op_LOAD_FAST
     elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
@@ -631,6 +673,15 @@ class TraceRunner(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_DELETE_FAST(self, state, inst):
         state.append(inst)
 
@@ -889,7 +940,7 @@ class TraceRunner(object):
         )
         state.push(res)
 
-    if PYVERSION in ((3, 12), (3, 13)):
+    if PYVERSION in ((3, 12), (3, 13), (3, 14)):
 
         def op_BINARY_SLICE(self, state, inst):
             end = state.pop()
@@ -913,7 +964,7 @@ class TraceRunner(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, state, inst):
             end = state.pop()
@@ -952,7 +1003,7 @@ class TraceRunner(object):
     op_POP_JUMP_IF_TRUE = _op_POP_JUMP_IF
     op_POP_JUMP_IF_FALSE = _op_POP_JUMP_IF
 
-    if PYVERSION in ((3, 12), (3, 13)):
+    if PYVERSION in ((3, 12), (3, 13), (3, 14)):
         op_POP_JUMP_IF_NONE = _op_POP_JUMP_IF
         op_POP_JUMP_IF_NOT_NONE = _op_POP_JUMP_IF
     elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
@@ -1018,7 +1069,7 @@ class TraceRunner(object):
         state.append(inst, retval=state.pop(), castval=state.make_temp())
         state.terminate()
 
-    if PYVERSION in ((3, 12), (3, 13)):
+    if PYVERSION in ((3, 12), (3, 13), (3, 14)):
 
         def op_RETURN_CONST(self, state, inst):
             res = state.make_temp("const")
@@ -1035,7 +1086,7 @@ class TraceRunner(object):
         state.append(inst, value=val, res=res)
         state.push(res)
 
-    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
 
         def op_RAISE_VARARGS(self, state, inst):
             if inst.arg == 0:
@@ -1098,7 +1149,7 @@ class TraceRunner(object):
         blk = state.pop_block()
         state.reset_stack(blk["entry_stack"])
 
-    if PYVERSION in ((3, 13),):
+    if PYVERSION in ((3, 13), (3, 14)):
 
         def op_END_FOR(self, state, inst):
             state.pop()
@@ -1146,35 +1197,43 @@ class TraceRunner(object):
             )
         )
 
-    def op_BEFORE_WITH(self, state, inst):
-        # Almost the same as py3.10 SETUP_WITH just lacking the finally block.
-        cm = state.pop()  # the context-manager
-
-        yielded = state.make_temp()
-        exitfn = state.make_temp(prefix="setup_with_exitfn")
-
-        state.push(exitfn)
-        state.push(yielded)
-
-        # Gather all exception entries for this WITH. There maybe multiple
-        # entries; esp. for nested WITHs.
-        bc = state._bytecode
-        ehhead = bc.find_exception_entry(inst.next)
-        ehrelated = [ehhead]
-        for eh in bc.exception_entries:
-            if eh.target == ehhead.target:
-                ehrelated.append(eh)
-        end = max(eh.end for eh in ehrelated)
-        state.append(inst, contextmanager=cm, exitfn=exitfn, end=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, state, inst):
+            # Almost the same as py3.10 SETUP_WITH just lacking the finally
+            # block.
+            cm = state.pop()  # the context-manager
+
+            yielded = state.make_temp()
+            exitfn = state.make_temp(prefix="setup_with_exitfn")
+
+            state.push(exitfn)
+            state.push(yielded)
+
+            # Gather all exception entries for this WITH. There maybe multiple
+            # entries; esp. for nested WITHs.
+            bc = state._bytecode
+            ehhead = bc.find_exception_entry(inst.next)
+            ehrelated = [ehhead]
+            ehrelated.extend(
+                eh for eh in bc.exception_entries if eh.target == ehhead.target
+            )
+            end = max(eh.end for eh in ehrelated)
+            state.append(inst, contextmanager=cm, exitfn=exitfn, end=end)
 
-        state.push_block(
-            state.make_block(
-                kind="WITH",
-                end=end,
+            state.push_block(
+                state.make_block(
+                    kind="WITH",
+                    end=end,
+                )
             )
-        )
-        # Forces a new block
-        state.fork(pc=inst.next)
+            # Forces a new block
+            state.fork(pc=inst.next)
+    else:
+        raise NotImplementedError(PYVERSION)
 
     def op_SETUP_WITH(self, state, inst):
         cm = state.pop()  # the context-manager
@@ -1229,7 +1288,7 @@ class TraceRunner(object):
             end=inst.get_jump_target(),
         )
 
-    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
 
         def op_POP_EXCEPT(self, state, inst):
             state.pop()
@@ -1262,12 +1321,19 @@ class TraceRunner(object):
             state.append(inst, kind="with")
         state.fork(pc=inst.next)
 
-    def op_BINARY_SUBSCR(self, state, inst):
-        index = state.pop()
-        target = state.pop()
-        res = state.make_temp()
-        state.append(inst, index=index, target=target, res=res)
-        state.push(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, state, inst):
+            index = state.pop()
+            target = state.pop()
+            res = state.make_temp()
+            state.append(inst, index=index, target=target, res=res)
+            state.push(res)
+    else:
+        raise NotImplementedError(PYVERSION)
 
     def op_STORE_SUBSCR(self, state, inst):
         index = state.pop()
@@ -1283,7 +1349,7 @@ class TraceRunner(object):
     def op_CALL(self, state, inst):
         narg = inst.arg
         args = list(reversed([state.pop() for _ in range(narg)]))
-        if PYVERSION == (3, 13):
+        if PYVERSION in ((3, 13), (3, 14)):
             null_or_self = state.pop()
             # position of the callable is fixed
             callable = state.pop()
@@ -1326,7 +1392,7 @@ class TraceRunner(object):
         state.append(inst, func=func, args=args, names=names, res=res)
         state.push(res)
 
-    if PYVERSION in ((3, 13),):
+    if PYVERSION in ((3, 13), (3, 14)):
 
         def op_CALL_KW(self, state, inst):
             narg = inst.arg
@@ -1348,7 +1414,25 @@ class TraceRunner(object):
     else:
         raise NotImplementedError(PYVERSION)
 
-    if PYVERSION in ((3, 13),):
+    if PYVERSION in ((3, 14),):
+
+        def op_CALL_FUNCTION_EX(self, state, inst):
+            # (func, unused, callargs, kwargs -- result))
+            # In 3.14 CALL_FUNCTION_EX always take a kwargs argument
+            # https://github.com/python/cpython/pull/129226
+            varkwarg = state.pop()
+            if _is_null_temp_reg(varkwarg):
+                varkwarg = None
+            vararg = state.pop()
+            state.pop()  # unused
+            func = state.pop()
+
+            res = state.make_temp()
+            state.append(
+                inst, func=func, vararg=vararg, varkwarg=varkwarg, res=res
+            )
+            state.push(res)
+    elif PYVERSION in ((3, 13),):
 
         def op_CALL_FUNCTION_EX(self, state, inst):
             # (func, unused, callargs, kwargs if (oparg & 1) -- result))
@@ -1408,7 +1492,7 @@ class TraceRunner(object):
         for val in duped:
             state.push(val)
 
-    if PYVERSION in ((3, 12), (3, 13)):
+    if PYVERSION in ((3, 12), (3, 13), (3, 14)):
 
         def op_CALL_INTRINSIC_1(self, state, inst):
             # See https://github.com/python/cpython/blob/v3.12.0rc2/Include/
@@ -1603,6 +1687,13 @@ class TraceRunner(object):
         state.append(inst, items=items, res=res)
         state.push(res)
 
+    def op_SET_ADD(self, state, inst):
+        value = state.pop()
+        target = state.get_tos()
+        addvar = state.make_temp()
+        res = state.make_temp()
+        state.append(inst, value=value, target=target, addvar=addvar, res=res)
+
     def op_SET_UPDATE(self, state, inst):
         value = state.pop()
         index = inst.arg
@@ -1639,7 +1730,7 @@ class TraceRunner(object):
         )
         state.push(indval)
         end = inst.get_jump_target()
-        if PYVERSION in ((3, 12), (3, 13)):
+        if PYVERSION in ((3, 12), (3, 13), (3, 14)):
             # Changed in version 3.12: Up until 3.11 the iterator was
             # popped when it was exhausted. Now this is handled using END_FOR
             # op code.
@@ -1665,10 +1756,17 @@ class TraceRunner(object):
         op = dis._nb_ops[inst.arg][1]
         rhs = state.pop()
         lhs = state.pop()
-        op_name = ALL_BINOPS_TO_OPERATORS[op].__name__
-        res = state.make_temp(prefix=f"binop_{op_name}")
-        state.append(inst, op=op, lhs=lhs, rhs=rhs, res=res)
-        state.push(res)
+        if op == "[]":
+            # Special case 3.14 -- body of BINARY_SUBSCR now here
+            assert PYVERSION == (3, 14)
+            res = state.make_temp()
+            state.append(inst, op=op, lhs=lhs, rhs=rhs, res=res)
+            state.push(res)
+        else:
+            op_name = ALL_BINOPS_TO_OPERATORS[op].__name__
+            res = state.make_temp(prefix=f"binop_{op_name}")
+            state.append(inst, op=op, lhs=lhs, rhs=rhs, res=res)
+            state.push(res)
 
     def _unaryop(self, state, inst):
         val = state.pop()
@@ -1725,7 +1823,7 @@ class TraceRunner(object):
     op_BINARY_XOR = _binaryop
 
     def op_MAKE_FUNCTION(self, state, inst, MAKE_CLOSURE=False):
-        if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+        if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
             # https://github.com/python/cpython/commit/2f180ce
             # name set via co_qualname
             name = None
@@ -1738,7 +1836,7 @@ class TraceRunner(object):
             raise NotImplementedError(PYVERSION)
         code = state.pop()
         closure = annotations = kwdefaults = defaults = None
-        if PYVERSION in ((3, 13),):
+        if PYVERSION in ((3, 13), (3, 14)):
             assert inst.arg is None
             # SET_FUNCTION_ATTRIBUTE is responsible for setting
             # closure, annotations, kwdefaults and defaults.
@@ -1765,7 +1863,7 @@ class TraceRunner(object):
         state.push(res)
 
     def op_SET_FUNCTION_ATTRIBUTE(self, state, inst):
-        assert PYVERSION in ((3, 13),)
+        assert PYVERSION in ((3, 13), (3, 14))
         make_func_stack = state.pop()
         data = state.pop()
         if inst.arg == 0x1:
@@ -1793,10 +1891,17 @@ class TraceRunner(object):
         state.append(inst, res=res)
         state.push(res)
 
-    def op_LOAD_ASSERTION_ERROR(self, state, inst):
-        res = state.make_temp("assertion_error")
-        state.append(inst, res=res)
-        state.push(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, state, inst):
+            res = state.make_temp("assertion_error")
+            state.append(inst, res=res)
+            state.push(res)
+    else:
+        raise NotImplementedError(PYVERSION)
 
     def op_CHECK_EXC_MATCH(self, state, inst):
         pred = state.make_temp("predicate")
@@ -1815,7 +1920,7 @@ class TraceRunner(object):
         state.fork(pc=inst.next)
         state.fork(pc=inst.get_jump_target())
 
-    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
 
         def op_RERAISE(self, state, inst):
             # This isn't handled, but the state is set up anyway
@@ -1845,7 +1950,7 @@ class TraceRunner(object):
     # NOTE: Please see notes in `interpreter.py` surrounding the implementation
     # of LOAD_METHOD and CALL_METHOD.
 
-    if PYVERSION in ((3, 12), (3, 13)):
+    if PYVERSION in ((3, 12), (3, 13), (3, 14)):
         # LOAD_METHOD has become a pseudo-instruction in 3.12
         pass
     elif PYVERSION in ((3, 11),):
@@ -1870,6 +1975,147 @@ class TraceRunner(object):
     def op_CALL_METHOD(self, state, inst):
         self.op_CALL_FUNCTION(state, inst)
 
+    if PYVERSION in ((3, 14),):
+        # New in 3.14, replaces BEFORE_WITH.
+        def op_LOAD_SPECIAL(self, state, inst):
+            # The "special" methods mapping for LOAD_SPECIAL is:
+            #
+            # special_methods = {
+            #     0: '__enter__',
+            #     1: '__exit__',
+            #     2: '__aenter__',
+            #     3: '__aexit__',
+            # }
+            if dis._special_method_names[inst.arg] not in [
+                "__enter__",
+                "__exit__",
+            ]:
+                raise NotImplementedError("async special methods not supported")
+
+            # This implementation of LOAD_SPECIAL is somewhat unusual for a
+            # Numba bytecode handler.
+            #
+            # Essentially this comes from the insight, that with Python 3.14
+            # the bytecode `BEFORE_WITH` is replaced by `LOAD_SPECIAL`. But
+            # this is not a simple replacement. In fact, the single
+            # `BEFORE_WITH` is replaced by the following sequence of bytecodes:
+            #
+            #   COPY(arg=1, lineno=X)
+            #   LOAD_SPECIAL(arg=1, lineno=X)  -- loading __exit__ --
+            #   SWAP(arg=2, lineno=X)
+            #   SWAP(arg=3, lineno=X)
+            #   LOAD_SPECIAL(arg=0, lineno=X)  -- loading __enter__ --
+            #   CALL(arg=0, lineno=X)          -- calling __enter__ --
+            #   POP_TOP(arg=None, lineno=X)
+            #
+            #   Basically, after seeing the first `LOAD_SPECIAL` we can consume
+            #   all the bytecodes up until the `POP_TOP` and leave the stack
+            #   with a single copy of current TOS + the temp var to denote the
+            #   `__exit__` function. We can also reject syntax of the form:
+            #
+            #   with context as c:
+            #       pass
+            #
+            # Using the fact that the `CALL` to `__enter__` must be followed by
+            # as POP_TOP, otherwise it's using `with as`.
+
+            # Pop top of stack once for first LOAD_SPECIAL
+            tos = state.pop()
+            # Pop top of stack second time for second LOAD_SPECIAL
+            _ = state.pop()
+
+            # Fake an exit method, will not be called and removed from Numba IR
+            # before final processing is complete. Only need this such that the
+            # `CALL` op when closing the with-block can be simulated as a stack
+            # effect.
+            method = state.make_temp(prefix="setup_with_exitfn")
+            # Cache current instruction (the LOAD_SPECIAL).
+            old_inst = inst
+
+            # Now we need to consume the instructions in the known sequence.
+            for i, a in (
+                ("SWAP", 2),
+                ("SWAP", 3),
+                ("LOAD_SPECIAL", 0),
+                ("CALL", 0),
+            ):
+                state.advance_pc()
+                inst = state.get_inst()
+                if inst.opname != i or inst.arg != a:
+                    raise UnsupportedBytecodeError(
+                        "Unsupported bytecode pattern for 'LOAD_SPECIAL'."
+                    )
+
+            # POP_TOP
+            state.advance_pc()
+            inst = state.get_inst()
+            # Special case, the `CALL` must be followed by a `POP_TOP`.
+            # Otherwise this is an unsupported construct.
+            #
+            # See: `_guard_with_as` for how this is handled for 3.13 and below.
+            if inst.opname != "POP_TOP":
+                msg = (
+                    "The 'with (context manager) as "
+                    "(variable):' construct is not "
+                    "supported."
+                )
+                raise UnsupportedBytecodeError(msg)
+            assert inst.arg is None
+
+            # Finished consuming bytecode pattern.
+
+            # Find the end of the with-block using the exception tables using
+            # the instruction offset of the `POP_TOP` instruction.
+            bc = state._bytecode
+            ehhead = bc.find_exception_entry(inst.offset)
+            ehrelated = [ehhead]
+            ehrelated.extend(
+                eh for eh in bc.exception_entries if eh.target == ehhead.target
+            )
+            end = max(eh.end for eh in ehrelated)
+
+            # Push the `__exit__` method (or null) to the stack,
+            # followed by the original tos (which is the instatiated context
+            # manager). This is such that the `CALL` after the with-block can
+            # be simulated.
+            state.push(method)
+            state.push(tos)
+            # Record the instruction.
+            state.append(
+                old_inst, contextmanager=tos, exit_method=method, block_end=end
+            )
+
+            # Insert WITH-block.
+            state.push_block(
+                state.make_block(
+                    kind="WITH",
+                    end=end,
+                )
+            )
+            # And fork to force a new block.
+            state.fork(pc=inst.next)
+
+    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, state, inst):
+            oparg = inst.arg
+            if isinstance(dis._common_constants[oparg], AssertionError):
+                name = "assertion_error"
+            else:
+                raise NotImplementedError
+            res = state.make_temp(name)
+            state.append(inst, res=res, idx=oparg)
+            state.push(res)
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+        pass
+    else:
+        raise NotImplementedError(PYVERSION)
+
 
 @total_ordering
 class _State(object):
@@ -2118,7 +2364,7 @@ class _State(object):
                 stack.append(self.make_temp())
         # Handle changes on the blockstack
         blockstack = list(self._blockstack)
-        if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+        if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
             # pop expired block in destination pc
             while blockstack:
                 top = blockstack[-1]
@@ -2229,7 +2475,7 @@ class StatePy313(StatePy311):
         return self._make_func_attrs[make_func_res]
 
 
-if PYVERSION in ((3, 13),):
+if PYVERSION in ((3, 13), (3, 14)):
     State = StatePy313
 elif PYVERSION in ((3, 11), (3, 12)):
     State = StatePy311
@@ -2273,7 +2519,7 @@ def adapt_state_infos(state):
             data.update(state.get_function_attributes(data["res"]))
         return offset, data
 
-    if PYVERSION in ((3, 13),):
+    if PYVERSION in ((3, 13), (3, 14)):
         insts = tuple(map(process_function_attributes, state.instructions))
     elif PYVERSION in ((3, 9), (3, 10), (3, 11), (3, 12)):
         insts = tuple(state.instructions)