Home - Summaries: (main) : (py3.11) : Everything - Nightly builds - Benchmarks - RPython - Builders - About

pypy/interpreter/test/apptest_exceptions.py::test_nested_except_raise_stored

def test_nested_except_raise_stored():
        # CPython 3.11 exception table for this pattern:
        #   try body -> outer_handler
        #   inner try body -> inner_handler
        #   inner handler check+STORE -> inner outer_cleanup
        #   inner handler body (incl RAISE_VARARGS) -> inner cleanup_end
        #   inner cleanup_end -> inner outer_cleanup
        #   outer handler check -> outer outer_cleanup
        import dis
        def f():
            try:
                z = 0
                try:
                    "x" + 1
                except TypeError as e:
                    z = 5
                    raise e
            except TypeError:
                return z
        print()
>       dis.dis(f)

interpreter/test/apptest_exceptions.py:320: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

x = <code object f, file "/build_dir/own-linux-x86-64/build/pypy/interpreter/test/apptest_exceptions.py", line 309>

    def dis(x=None, *, file=None, depth=None, show_caches=False, adaptive=False):
        """Disassemble classes, methods, functions, and other compiled objects.
    
        With no argument, disassemble the last traceback.
    
        Compiled objects currently include generator objects, async generator
        objects, and coroutine objects, all of which store their code object
        in a special attribute.
        """
        if x is None:
            distb(file=file, show_caches=show_caches, adaptive=adaptive)
            return
        # Extract functions from methods.
        if hasattr(x, '__func__'):
            x = x.__func__
        # Extract compiled code objects from...
        if hasattr(x, '__code__'):  # ...a function, or
            x = x.__code__
        elif hasattr(x, 'gi_code'):  #...a generator object, or
            x = x.gi_code
        elif hasattr(x, 'ag_code'):  #...an asynchronous generator object, or
            x = x.ag_code
        elif hasattr(x, 'cr_code'):  #...a coroutine.
            x = x.cr_code
        # Perform the disassembly.
        if hasattr(x, '__dict__'):  # Class or module
            items = sorted(x.__dict__.items())
            for name, x1 in items:
                if isinstance(x1, _have_code):
                    print("Disassembly of %s:" % name, file=file)
                    try:
                        dis(x1, file=file, depth=depth, show_caches=show_caches, adaptive=adaptive)
                    except TypeError as msg:
                        print("Sorry:", msg, file=file)
                    print(file=file)
        elif hasattr(x, 'co_code'): # Code object
>           _disassemble_recursive(x, file=file, depth=depth, show_caches=show_caches, adaptive=adaptive)

../lib-python/3/dis.py:114: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

co = <code object f, file "/build_dir/own-linux-x86-64/build/pypy/interpreter/test/apptest_exceptions.py", line 309>

    def _disassemble_recursive(co, *, file=None, depth=None, show_caches=False, adaptive=False):
>       disassemble(co, file=file, show_caches=show_caches, adaptive=adaptive)

../lib-python/3/dis.py:555: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

co = <code object f, file "/build_dir/own-linux-x86-64/build/pypy/interpreter/test/apptest_exceptions.py", line 309>
lasti = W_IntObject(-1)

    def disassemble(co, lasti=-1, *, file=None, show_caches=False, adaptive=False):
        """Disassemble a code object."""
        linestarts = dict(findlinestarts(co))
        exception_entries = _parse_exception_table(co)
>       _disassemble_bytes(_get_code_array(co, adaptive),

../lib-python/3/dis.py:548: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

code = W_BytesObject('\t\x00d\x01}\x00\t\x00d\x02d\x03\x17\x00\x01\x00d\x00S\x00#\x00...\x01#\x00t\x00$\x00r%\x01\x00|\x00\x06\x00Y\x00S\x00w\x01w\x00&\x03Y\x00w\x01')
lasti = W_IntObject(-1), varname_from_oparg = bound method _varname_from_oparg
names = W_TupleObject(W_UnicodeObject('TypeError'))
co_consts = W_TupleObject(<pypy.objspace.std.noneobject.W_NoneObject object at 0x7fdfb211dad0>, W_IntObject(0), W_UnicodeObject('x'), W_IntObject(1), W_IntObject(5))
linestarts = W_DictObject(<pypy.objspace.std.dictmultiobject.IntDictStrategy object at 0x7fdfb152f1d0>)

    def _disassemble_bytes(code, lasti=-1, varname_from_oparg=None,
                           names=None, co_consts=None, linestarts=None,
                           *, file=None, line_offset=0, exception_entries=(),
                           co_positions=None, show_caches=False):
        # Omit the line number column entirely if we have no line number info
        show_lineno = bool(linestarts)
        if show_lineno:
            maxlineno = max(linestarts.values()) + line_offset
            if maxlineno >= 1000:
                lineno_width = len(str(maxlineno))
            else:
                lineno_width = 3
        else:
            lineno_width = 0
        maxoffset = len(code) - 2
        if maxoffset >= 10000:
            offset_width = len(str(maxoffset))
        else:
            offset_width = 4
>       for instr in _get_instructions_bytes(code, varname_from_oparg, names,

../lib-python/3/dis.py:586: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

code = W_BytesObject('\t\x00d\x01}\x00\t\x00d\x02d\x03\x17\x00\x01\x00d\x00S\x00#\x00...\x01#\x00t\x00$\x00r%\x01\x00|\x00\x06\x00Y\x00S\x00w\x01w\x00&\x03Y\x00w\x01')
varname_from_oparg = bound method _varname_from_oparg
names = W_TupleObject(W_UnicodeObject('TypeError'))
co_consts = W_TupleObject(<pypy.objspace.std.noneobject.W_NoneObject object at 0x7fdfb211dad0>, W_IntObject(0), W_UnicodeObject('x'), W_IntObject(1), W_IntObject(5))
linestarts = W_DictObject(<pypy.objspace.std.dictmultiobject.IntDictStrategy object at 0x7fdfb152f1d0>)
line_offset = W_IntObject(0)
exception_entries = W_ListObject(<pypy.objspace.std.listobject.ObjectListStrategy object at 0x7fdf...ct(72), W_IntObject(76), W_IntObject(76), W_IntObject(1), W_BoolObject(True))])
co_positions = <pypy.objspace.std.iterobject.W_FastListIterObject object at 0x7fdfae2e6b90>
show_caches = W_BoolObject(False)

    def _get_instructions_bytes(code, varname_from_oparg=None,
                                names=None, co_consts=None,
                                linestarts=None, line_offset=0,
                                exception_entries=(), co_positions=None,
                                show_caches=False):
        """Iterate over the instructions in a bytecode string.
    
        Generates a sequence of Instruction namedtuples giving the details of each
        opcode.  Additional information about the code's runtime environment
        (e.g. variable names, co_consts) can be specified using optional
        arguments.
    
        """
        co_positions = co_positions or iter(())
        get_name = None if names is None else names.__getitem__
        labels = set(findlabels(code))
        for start, end, target, _, _ in exception_entries:
            for i in range(start, end):
                labels.add(target)
        starts_line = None
        for offset, op, arg in _unpack_opargs(code):
            if linestarts is not None:
                starts_line = linestarts.get(offset, None)
                if starts_line is not None:
                    starts_line += line_offset
            is_jump_target = offset in labels
            argval = None
            argrepr = ''
            positions = Positions(*next(co_positions, ()))
            deop = _deoptop(op)
            caches = _inline_cache_entries[deop]
            if arg is not None:
                #  Set argval to the dereferenced value of the argument when
                #  available, and argrepr to the string representation of argval.
                #    _disassemble_bytes needs the string repr of the
                #    raw name index for LOAD_GLOBAL, LOAD_CONST, etc.
                argval = arg
                if deop in hasconst:
                    argval, argrepr = _get_const_info(deop, arg, co_consts)
                elif deop in hasname:
                    if deop == LOAD_GLOBAL:
                        argval, argrepr = _get_name_info(arg//2, get_name)
                        if (arg & 1) and argrepr:
                            argrepr = "NULL + " + argrepr
                    elif deop == LOAD_ATTR:
                        argval, argrepr = _get_name_info(arg//2, get_name)
                        if (arg & 1) and argrepr:
                            argrepr = "NULL|self + " + argrepr
                    elif deop == LOAD_SUPER_ATTR:
                        argval, argrepr = _get_name_info(arg//4, get_name)
                        if (arg & 1) and argrepr:
                            argrepr = "NULL|self + " + argrepr
                    else:
                        argval, argrepr = _get_name_info(arg, get_name)
                elif deop in hasjabs:
                    argval = arg*2
                    argrepr = "to " + repr(argval)
                elif deop in hasjrel:
                    signed_arg = -arg if _is_backward_jump(deop) else arg
                    argval = offset + 2 + signed_arg*2
                    argval += 2 * caches
                    argrepr = "to " + repr(argval)
                elif deop in haslocal or deop in hasfree:
                    argval, argrepr = _get_name_info(arg, varname_from_oparg)
                elif deop in hascompare:
                    argval = cmp_op[arg>>4]
                    argrepr = argval
                elif deop == FORMAT_VALUE:
                    argval, argrepr = FORMAT_VALUE_CONVERTERS[arg & 0x3]
                    argval = (argval, bool(arg & 0x4))
                    if argval[1]:
                        if argrepr:
                            argrepr += ', '
                        argrepr += 'with format'
                elif deop == MAKE_FUNCTION:
                    argrepr = ', '.join(s for i, s in enumerate(MAKE_FUNCTION_FLAGS)
                                        if arg & (1<<i))
>               elif deop == BINARY_OP:
E               (application-level) NameError: name 'BINARY_OP' is not defined

../lib-python/3/dis.py:512: NameError
---------- Captured stdout call ----------

310           0 NOP

311           2 LOAD_CONST               1 (0)
              4 STORE_FAST               0 (z)

312           6 NOP

313           8 LOAD_CONST               2 ('x')
             10 LOAD_CONST               3 (1)
             12 BINARY_ADD
             14 POP_TOP
             16 LOAD_CONST               0 (None)
             18 RETURN_VALUE
        >>   20 PUSH_EXC_INFO

314          22 LOAD_GLOBAL              0 (TypeError)
             32 STORE_FAST               0 (z)

316          34 LOAD_FAST                1 (e)
builder: own-linux-x86-64 build #10880+
test: pypy/interpreter/test/apptest_exceptions.py::test_nested_except_raise_stored