Support for JUMP_BACKWARD

[greenozon]

According to this article the JUMP_BACKWARD was a replacement for the same opcode JUMP_ABSOLUTE
https://bugs.python.org/issue47120

Test Case

def JUMP_BACKWARD():
    iterable = [1, 2, 3]
    for item in iterable:
        pass

    while True:
        break

pycdas for TC

[Code]
    File Name: jmp_back.py
    Object Name: <module>
    Qualified Name: <module>
    Arg Count: 0
    Pos Only Arg Count: 0
    KW Only Arg Count: 0
    Stack Size: 1
    Flags: 0x00000000
    [Names]
        'JUMP_BACKWARD'
    [Locals+Names]
    [Constants]
        [Code]
            File Name: jmp_back.py
            Object Name: JUMP_BACKWARD
            Qualified Name: JUMP_BACKWARD
            Arg Count: 0
            Pos Only Arg Count: 0
            KW Only Arg Count: 0
            Stack Size: 2
            Flags: 0x00000003 (CO_OPTIMIZED | CO_NEWLOCALS)
            [Names]
            [Locals+Names]
                'iterable'
                'item'
            [Constants]
                None
                (
                    1
                    2
                    3
                )
            [Disassembly]
                0       RESUME                          0
                2       BUILD_LIST                      0
                4       LOAD_CONST                      1: (1, 2, 3)
                6       LIST_EXTEND                     1
                8       STORE_FAST                      0: iterable
                10      LOAD_FAST                       0: iterable
                12      GET_ITER
                14      FOR_ITER                        2 (to 20)
                18      STORE_FAST                      1: item
                20      JUMP_BACKWARD                   4 (to 14)
                22      END_FOR
                24      NOP
                26      RETURN_CONST                    0: None
        None
    [Disassembly]
        0       RESUME                          0
        2       LOAD_CONST                      0: <CODE> JUMP_BACKWARD
        4       MAKE_FUNCTION                   0
        6       STORE_NAME                      0: JUMP_BACKWARD
        8       RETURN_CONST                    1: None

before

def JUMP_BACKWARD():
Unsupported opcode: JUMP_BACKWARD
    iterable = [
        1,
        2,
        3]
# WARNING: Decompyle incomplete

after

def JUMP_BACKWARD():
Unsupported opcode: END_FOR
    iterable = [
        1,
        2,
        3]
# WARNING: Decompyle incomplete

[greenozon]

@zrax Do you think it makes sense to add support into this PR for the next missed operand?

PS the test was done on Python 3.12

[TiZCrocodile]

I compiled with pycdc, and it doesn't work if you just add the line case Pyc::JUMP_BACKWARD_A:
thats what I got:
the source:

l = [ch for ch in 'hello']

python 3.11: (didn't work, because JUMP_BACKWARD is used, but implementation isn't exactly like JUMP_ABSOLUTE)

# Source Generated with Decompyle++
# File: test_311.pyc (Python 3.11)

l = 'hello'()

python 3.8: (still didn't work, but thats because of list comprehension and lambda together is not supported yet as you can see)

# Source Generated with Decompyle++
# File: test_38.pyc (Python 3.8)

l = (lambda .0: [ ch for ch in .0 ])('hello')

the bytecode is almost exactly the same, only difference is JUMP_BACKWARD instead of JUMP_ABSOLUTE

[greenozon]

do you mean this opcode has diff meaning in diff Python versions?

[TiZCrocodile]

I mean that the bytecode of this source code

l = [ch for ch in 'hello']

between version 3.10 and 3.11 is this:
3.10:

  1           0 LOAD_CONST               0 (<code object <listcomp> at 0x000001AEABDC8F50, file "test.py", line 1>)
              2 LOAD_CONST               1 ('<listcomp>')
              4 MAKE_FUNCTION            0
              6 LOAD_CONST               2 ('hello')
              8 GET_ITER
             10 CALL_FUNCTION            1
             12 STORE_NAME               0 (l)
             14 LOAD_CONST               3 (None)
             16 RETURN_VALUE

Disassembly of <code object <listcomp> at 0x000001AEABDC8F50, file "test.py", line 1>:
  1           0 BUILD_LIST               0
              2 LOAD_FAST                0 (.0)
        >>    4 FOR_ITER                 4 (to 14)
              6 STORE_FAST               1 (ch)
              8 LOAD_FAST                1 (ch)
             10 LIST_APPEND              2
             12 JUMP_ABSOLUTE            2 (to 4)
        >>   14 RETURN_VALUE

3.11:

  0           0 RESUME                   0

  1           2 LOAD_CONST               0 (<code object <listcomp> at 0x0000028633FF92E0, file "test.py", line 1>)
              4 MAKE_FUNCTION            0
              6 LOAD_CONST               1 ('hello')
              8 GET_ITER
             10 PRECALL                  0
             14 CALL                     0
             24 STORE_NAME               0 (l)
             26 LOAD_CONST               2 (None)
             28 RETURN_VALUE

Disassembly of <code object <listcomp> at 0x0000028633FF92E0, file "test.py", line 1>:
  1           0 RESUME                   0
              2 BUILD_LIST               0
              4 LOAD_FAST                0 (.0)
        >>    6 FOR_ITER                 4 (to 16)
              8 STORE_FAST               1 (ch)
             10 LOAD_FAST                1 (ch)
             12 LIST_APPEND              2
             14 JUMP_BACKWARD            5 (to 6)
        >>   16 RETURN_VALUE

if you look, there is not very much difference in the bytecode,
but the decompiled source code for these pyc's are different, which means that another thing has to be done, because even after adding the line you added, its still not supported.

[TiZCrocodile]

i would suggest to add, after the lines:

if (mod->verCompare(3, 10) >= 0)
    offs *= sizeof(uint16_t); // // BPO-27129

to add this lines, for it to work:

if (opcode == Pyc::JUMP_BACKWARD_A)
    offs = pos - offs;

then this way it is exactly like the jump absolute, and it will work, then you can compile the test file "test_for_loop_py3.8.py" for version 3.11 and add it to the compiled folder, i saw there is return None in the end, so maybe also get the whole code inside a function and remove the return statement,
after that compile it for 3.10,3.11,
tokenize by the token_dump script in the scripts folder
and thats all i think.

[Vendettail]

Proposal:

        case Pyc::JUMP_BACKWARD_A:
        case Pyc::JUMP_FORWARD_A:
        case Pyc::INSTRUMENTED_JUMP_FORWARD_A:
            {
                int offs = operand;
                if (mod->verCompare(3, 10) >= 0)
                    offs *= sizeof(uint16_t); // // BPO-27129

                if (opcode == Pyc::JUMP_BACKWARD_A)
                    offs *= -1;

[whoami730]

@greenozon can we have this pr please be reopened? This seems to have not made to master yet.

[greenozon]

Need to make sure it works 100% for diff python versions zoo...
could you help with testing?

[whoami730]

Need to make sure it works 100% for diff python versions zoo... could you help with testing?

Yeah sure, do let me know what is required. This seems to work okay for my pyc file with python 3.12.
On another note, is development of pycdc on hold? Or is it not on hold but contributions have stopped coming?

[GoldinSea]

Need to make sure it works 100% for diff python versions zoo... could you help with testing?

Yeah sure, do let me know what is required. This seems to work okay for my pyc file with python 3.12. On another note, is development of pycdc on hold? Or is it not on hold but contributions have stopped coming?

can you sent me release pycdc?,thanks

[whoami730]

can you sent me release pycdc?,thanks
@GoldinSea you can build pycdc off latest master. Do file an issue if you find some functionality missing.

[GoldinSea]

can you sent me release pycdc?,thanks
@GoldinSea you can build pycdc off latest master. Do file an issue if you find some functionality missing.

I don't know how to compile programs. None of the ones downloaded from the Internet can be used. They keep showing the message "jump backward"