Start formatting stack manip opcodes...

These are things like SWAP, COPY, DUP_TOP, ROT_XXX

Author: rocky

xdis/opcodes/format/basic.py

@@ -1,4 +1,4 @@
-# (C) Copyright 2023 by Rocky Bernstein
+# (C) Copyright 2023, 2025 by Rocky Bernstein
 #
 #  This program is free software; you can redistribute it and/or
 #  modify it under the terms of the GNU General Public License
@@ -17,7 +17,6 @@
 Routines for formatting opcodes.
 """
 
-
 def format_extended_arg(arg):
     return str(arg * (1 << 16))
 
@@ -47,7 +46,7 @@ def format_MAKE_FUNCTION_10_27(argc: int) -> str:
 
 
 # Up until 3.7
-def format_RAISE_VARARGS_older(argc):
+def format_RAISE_VARARGS_older(argc) -> str:
     assert 0 <= argc <= 3
     if argc == 0:
         return "reraise"
@@ -57,6 +56,12 @@ def format_RAISE_VARARGS_older(argc):
         return "exception, parameter"
     elif argc == 3:
         return "exception, parameter, traceback"
+    return ""
+
+def format_ROT_TWO(_: int) -> str:
+    # We add a space at the end as a sentinal to use in get_instruction_tos_str()
+    return "TOS, TOS1 = TOS1, TOS"
+
 
 
 opcode_arg_fmt_base = opcode_arg_fmt34 = {
@@ -65,4 +70,5 @@ def format_RAISE_VARARGS_older(argc):
     "CALL_FUNCTION_VAR_KW": format_CALL_FUNCTION_pos_name_encoded,
     "EXTENDED_ARG": format_extended_arg,
     "RAISE_VARARGS": format_RAISE_VARARGS_older,
+    "ROT_TWO": format_ROT_TWO,
 }

xdis/opcodes/format/extended.py

@@ -1,4 +1,4 @@
-# (C) Copyright 2023-2024 by Rocky Bernstein
+# (C) Copyright 2023-2025 by Rocky Bernstein
 #
 #  This program is free software; you can redistribute it and/or
 #  modify it under the terms of the GNU General Public License
@@ -16,11 +16,15 @@
 """
 Routines for formatting opcodes.
 """
+
+import re
 from typing import List, Optional, Tuple
 
 from xdis.instruction import Instruction
 from xdis.opcodes.format.basic import format_IS_OP, format_RAISE_VARARGS_older
 
+NULL_EXTENDED_OP = "", None
+
 
 def extended_format_binary_op(
     opc, instructions: List[Instruction], fmt_str: str
@@ -108,11 +112,7 @@ def extended_format_infix_binary_op(
             instructions[j].opcode in opc.operator_set
             and instructions[i].opcode in opc.operator_set
         ):
-            arg2 = (
-                instructions[j].tos_str
-                if instructions[j].tos_str is not None
-                else instructions[j].argrepr
-            )
+            arg2 = get_instruction_tos_str(instructions[j])
             start_offset = instructions[j].start_offset
             return f"{arg2}{op_str}{arg1}", start_offset
         elif instructions[j].start_offset is not None:
@@ -265,7 +265,7 @@ def extended_format_ATTR(
         instr1.tos_str
         or instr1.opcode in opc.NAME_OPS | opc.CONST_OPS | opc.LOCAL_OPS | opc.FREE_OPS
     ):
-        base = get_instruction_arg(instr1)
+        base = get_instruction_tos_str(instr1)
 
         return (
             f"{base}.{instructions[0].argrepr}",
@@ -448,6 +448,21 @@ def extended_format_COMPARE_OP(
     )
 
 
+def extended_format_DUP_TOP(
+    opc, instructions: List[Instruction]
+) -> Tuple[str, Optional[int]]:
+    """Try to extract TOS value and show that surrounded in a "push() ".
+      The trailing space at the used as a sentinal for `get_instruction_tos_str()`
+      which tries to remove the push() part when the operand value string is needed.
+    """
+
+    # We add a space at the end as a sentinal to use in get_instruction_tos_str()
+    if instructions[1].optype not in ['jrel', 'jabs']:
+        return extended_format_unary_op(opc, instructions, "push(%s) ")
+    else:
+        return NULL_EXTENDED_OP
+
+
 def extended_format_CALL_FUNCTION(opc, instructions) -> Tuple[str, Optional[int]]:
     """call_function_inst should be a "CALL_FUNCTION" instruction. Look in
     `instructions` to see if we can find a method name.  If not we'll
@@ -468,7 +483,7 @@ def extended_format_CALL_FUNCTION(opc, instructions) -> Tuple[str, Optional[int]
 
     assert i is not None
     if i >= len(instructions) - 1:
-        return "", None
+        return NULL_EXTENDED_OP
 
     fn_inst = instructions[i + 1]
     if fn_inst.opcode in opc.operator_set:
@@ -480,7 +495,7 @@ def extended_format_CALL_FUNCTION(opc, instructions) -> Tuple[str, Optional[int]
         arglist.reverse()
         s = f'{fn_name}({", ".join(arglist)})'
         return s, start_offset
-    return "", None
+    return NULL_EXTENDED_OP
 
 
 def extended_format_IMPORT_FROM(
@@ -493,7 +508,8 @@ def extended_format_IMPORT_FROM(
             instructions[i].start_offset, instructions, 1
         )
         if i is None:
-            return "", None
+            return NULL_EXTENDED_OP
+
     module_name = get_instruction_arg(instructions[i])
     if module_name.startswith("import_module("):
         module_name = module_name[len("import_module(") : -1]
@@ -647,7 +663,7 @@ def extended_format_CALL_METHOD(opc, instructions) -> Tuple[str, Optional[int]]:
     arglist, arg_count, first_arg = get_arglist(instructions, 0, arg_count)
 
     if first_arg is None or first_arg >= len(instructions) - 1:
-        return "", None
+        return NULL_EXTENDED_OP
 
     fn_inst = instructions[first_arg + 1]
     if fn_inst.opcode in opc.operator_set and arglist is not None:
@@ -657,7 +673,8 @@ def extended_format_CALL_METHOD(opc, instructions) -> Tuple[str, Optional[int]]:
             arglist.reverse()
             s = f'{fn_name}({", ".join(arglist)})'
             return s, start_offset
-    return "", None
+    return NULL_EXTENDED_OP
+
 
 
 def extended_format_RAISE_VARARGS_older(
@@ -771,6 +788,18 @@ def get_instruction_arg(inst: Instruction, argval=None) -> str:
     return inst.tos_str if inst.tos_str is not None else argval
 
 
+def get_instruction_tos_str(inst: Instruction) -> str:
+    if inst.tos_str is not None:
+        argval = inst.tos_str
+        argval_without_push = re.match(r"^push\((.+)\) ", argval)
+        if argval_without_push:
+            # remove surrounding "push(...)" string
+            argval = argval_without_push.group(1)
+    else:
+        argval = inst.argrepr
+    return argval
+
+
 def get_instruction_index_from_offset(
     target_offset: int, instructions: List[Instruction], start_index: int = 1
 ) -> Optional[int]:
@@ -858,6 +887,7 @@ def skip_cache(instructions: List[Instruction], i: int) -> int:
     "BUILD_TUPLE":           extended_format_BUILD_TUPLE,
     "CALL_FUNCTION":         extended_format_CALL_FUNCTION,
     "COMPARE_OP":            extended_format_COMPARE_OP,
+    "DUP_TOP":               extended_format_DUP_TOP,
     "IMPORT_FROM":           extended_format_IMPORT_FROM,
     "IMPORT_NAME":           extended_format_IMPORT_NAME,
     "INPLACE_ADD":           extended_format_INPLACE_ADD,

xdis/opcodes/opcode_311.py

@@ -24,6 +24,7 @@
 from typing import Dict, List, Optional, Tuple
 
 import xdis.opcodes.opcode_310 as opcode_310
+from xdis.instruction import Instruction
 from xdis.opcodes.base import (
     binary_op,
     def_op,
@@ -244,10 +245,38 @@ def extended_format_BINARY_OP(opc, instructions) -> Tuple[str, Optional[int]]:
     return extended_format_binary_op(opc, instructions, f"%s {opname} %s")
 
 
-def format_BINARY_OP(arg) -> str:
+def extended_format_SWAP(
+    opc, instructions: List[Instruction]
+) -> Tuple[str, Optional[int]]:
+    """call_function_inst should be a "SWAP" instruction. See if
+    `we can find the two instructions to be swapped.  If not we'll
+    return None.
+
+    """
+    # From opcode description: argc indicates the total number of
+    # positional and keyword arguments.  Sometimes the function name
+    # is in the stack arg positions back.
+    # From opcode description: arg_count indicates the total number of
+    # positional and keyword arguments.
+
+    swap_instr = instructions[0]
+    i = swap_instr.argval
+    # s = ""
+
+    if (i is None or not (0 < i < len(instructions))):
+        return "", None
+
+    # To be continued
+    return "", None
+
+def format_BINARY_OP(arg: int) -> str:
     return _nb_ops[arg][1]
 
 
+def format_SWAP_OP(arg: int) -> str:
+    return f"TOS <-> TOS{arg-1}"
+
+
 opcode_arg_fmt311 = opcode_arg_fmt310.copy()
 del opcode_arg_fmt311["CALL_FUNCTION"]
 del opcode_arg_fmt311["CALL_FUNCTION_KW"]
@@ -257,6 +286,7 @@ def format_BINARY_OP(arg) -> str:
     **opcode_arg_fmt310,
     **{
         "BINARY_OP": format_BINARY_OP,
+        "SWAP": format_SWAP_OP,
     },
 }