First cut at RustPython disassembly

Author: rocky

xdis/codetype/code313rust.py

@@ -58,9 +58,9 @@ def __init__(
         co_name: str,
         co_qualname: str,
         co_firstlineno: int,
-        co_linetable: tuple[SourceLocation],
-        co_freevars,
-        co_cellvars,
+        co_linetable: bytes,
+        co_freevars: tuple,
+        co_cellvars: tuple,
         co_exceptiontable = tuple(),
         collection_order: Dict[Union[set, frozenset, dict], Tuple[Any]] = {},
         version_triple: Tuple[int, int, int]  = (0, 0, 0),

xdis/cross_dis.py

@@ -259,7 +259,7 @@ def op_has_argument(opcode: int, opc) -> bool:
     """
     Return True if `opcode` instruction has an operand.
     """
-    return opcode >= opc.HAVE_ARGUMENT
+    return opcode in opc.hasarg if hasattr(opc, "hasarg") else opcode >= opc.HAVE_ARGUMENT
 
 
 def pretty_flags(flags, python_implementation=PYTHON_IMPLEMENTATION) -> str:

xdis/disasm.py

@@ -68,6 +68,8 @@ def get_opcode(
                 lookup = "3.12.7Graal"
         else:
             lookup += "Graal"
+    elif python_implementation == PythonImplementation.RustPython:
+        lookup += "Rust"
     if lookup in op_imports.keys():
         if alternate_opmap is not None:
             # TODO: change bytecode version number comment line to indicate altered

xdis/load.py

@@ -224,7 +224,6 @@ def load_module_from_file_object(
 
     timestamp = 0
     file_offsets = {}
-    python_implementation = PythonImplementation.CPython
     try:
         magic = fp.read(4)
         magic_int = magic2int(magic)
@@ -354,6 +353,7 @@ def load_module_from_file_object(
     finally:
         fp.close()
 
+    python_implementation = PythonImplementation.RustPython if magic_int in RUSTPYTHON_MAGICS else PythonImplementation.CPython
     if is_pypy(magic_int, filename):
         python_implementation = PythonImplementation.PyPy
 

xdis/op_imports.py

@@ -64,6 +64,7 @@
     opcode_312,
     opcode_312graal,
     opcode_313,
+    opcode_313rust,
     opcode_314,
 )
 from xdis.version_info import PythonImplementation, version_tuple_to_str
@@ -187,6 +188,7 @@
     "3.12.0rc2": opcode_312,
     "3.12.0": opcode_312,
     "3.13.0rc3": opcode_313,
+    "3.13.0Rust": opcode_313rust,
     "3.14b3": opcode_314,
     "3.14.0": opcode_314,
     "3.14": opcode_314,

xdis/opcodes/base.py

@@ -188,11 +188,15 @@ def call_op(
     Put opcode in the class of instructions that perform calls.
     """
     loc["callop"].add(opcode)
+    if "hasarg" in loc:
+        loc["hasarg"].append(opcode)
     nargs_op(loc, name, opcode, pop, push, fallthrough)
 
 
 def compare_op(loc: dict, name: str, opcode: int, pop: int = 2, push: int = 1) -> None:
     def_op(loc, name, opcode, pop, push)
+    if "hasarg" in loc:
+        loc["hasarg"].append(opcode)
     loc["hascompare"].append(opcode)
     loc["binaryop"].add(opcode)
 
@@ -203,6 +207,8 @@ def conditional_op(loc: dict, name: str, opcode: int) -> None:
 
 def const_op(loc: dict, name: str, opcode: int, pop: int = 0, push: int = 1) -> None:
     def_op(loc, name, opcode, pop, push)
+    if "hasarg" in loc:
+        loc["hasarg"].append(opcode)
     loc["hasconst"].append(opcode)
     loc["nullaryop"].add(opcode)
 
@@ -225,6 +231,8 @@ def def_op(
 
 def free_op(loc: dict, name: str, opcode: int, pop: int = 0, push: int = 1) -> None:
     def_op(loc, name, opcode, pop, push)
+    if "hasarg" in loc:
+        loc["hasarg"].append(opcode)
     loc["hasfree"].append(opcode)
 
 
@@ -242,6 +250,8 @@ def jabs_op(
     """
     def_op(loc, name, opcode, pop, push, fallthrough=fallthrough)
     loc["hasjabs"].append(opcode)
+    if "hasarg" in loc:
+        loc["hasarg"].append(opcode)
     if conditional:
         loc["hascondition"].append(opcode)
 
@@ -252,12 +262,16 @@ def jrel_op(loc, name: str, opcode: int, pop: int=0, push: int=0, conditional=Fa
     """
     def_op(loc, name, opcode, pop, push, fallthrough)
     loc["hasjrel"].append(opcode)
+    if "hasarg" in loc:
+        loc["hasarg"].append(opcode)
     if conditional:
         loc["hascondition"].append(opcode)
 
 
 def local_op(loc, name, opcode: int, pop=0, push=1) -> None:
     def_op(loc, name, opcode, pop, push)
+    if "hasarg" in loc:
+        loc["hasarg"].append(opcode)
     loc["haslocal"].append(opcode)
     loc["nullaryop"].add(opcode)
 
@@ -268,6 +282,8 @@ def name_op(loc: dict, op_name, opcode: int, pop=-2, push=-2) -> None:
     """
     def_op(loc, op_name, opcode, pop, push)
     loc["hasname"].append(opcode)
+    if "hasarg" in loc:
+        loc["hasarg"].append(opcode)
     loc["nullaryop"].add(opcode)
 
 
@@ -278,6 +294,8 @@ def nargs_op(
     Put opcode in the class of instructions that have a variable number of (or *n*) arguments
     """
     def_op(loc, name, opcode, pop, push, fallthrough=fallthrough)
+    if "hasarg" in loc:
+        loc["hasarg"].append(opcode)
     loc["hasnargs"].append(opcode)