Start handling most recent RustPython..

It uses CPython 3.12's magic number!

Author: rocky

xdis/load.py

@@ -228,10 +228,24 @@ def load_module_from_file_object(
         magic = fp.read(4)
         magic_int = magic2int(magic)
 
+        if magic_int == 3531:
+            # this magic int is used for both 3.12 and 3.13Rust!
+            # Disambiguate using the fact that CPython 3.13 stores 0xe3
+            # "c" | 0x80 at offoset 0x10 while RustPython uses "c" (no 0x80).
+            fp.seek(0x10)
+            code_type = fp.read(1)
+            if code_type == b'c':
+                # Is RustPython 3.13 using CPython's 3.12 magic number.
+                magic_int = 35310
+            else:
+                assert code_type == b'\xe3', "Expecting magic int 3531 to have a code type b'0x63 or b'0x33' at offset 0x10"
+            fp.seek(0x04)
+
         # For reasons I don't understand, PyPy 3.2 stores a magic
         # of '0'...  The two values below are for Python 2.x and 3.x respectively
         if magic[0:1] in ["0", b"0"]:
             magic = int2magic(3180 + 7)
+            magic_int = magic2int(magic)
 
         try:
             # FIXME: use the internal routine below
@@ -245,10 +259,7 @@ def load_module_from_file_object(
             else:
                 raise ImportError(f"Bad magic number: '{magic}'")
 
-        if magic_int in [2657, 22138] + list(
-            RUSTPYTHON_MAGICS
-        ) + list(JYTHON_MAGICS):
-            version = magicint2version.get(magic_int, "")
+        version = magic_int2tuple(magic_int)
 
         if magic_int in INTERIM_MAGIC_INTS:
             raise ImportError(
@@ -268,8 +279,6 @@ def load_module_from_file_object(
 
         try:
             my_magic_int = PYTHON_MAGIC_INT
-            magic_int = magic2int(magic)
-            version = magic_int2tuple(magic_int)
 
             timestamp = None
             source_size = None

xdis/magics.py

@@ -53,7 +53,7 @@
     12897,  # RustPython 3.12.0 0.4.0
     13413,  # RustPython 3.13
     24881,  # RustPython 3.13   0.4.0
-    3531,   # RustPython 3.13   0.4.0 later version!
+    35310,  # RustPython 3.13   0.4.0 later version! Actually 3531 is stored in file
 )
 
 # A list of interim Python version magic numbers used, but were not
@@ -701,6 +701,9 @@ def __by_version(magic_versions: Dict[bytes, str]) -> dict:
 add_magic_from_int(13413, "3.13.0a.rust")  # RustPython 3.13.0
 add_magic_from_int(24881, "3.13.0b.rust")  # RustPython 3.13.0 0.4.0
 
+# Actually we should add 3531, but that already means CPython 3.12!
+add_magic_from_int(35310, "3.13.1.rust")  # RustPython 3.13.0 0.4.0
+
 # Graal Python.  Graal uses its own JVM-ish CPython bytecode, not
 # true CPython or PyPy bytecode.
 #

xdis/op_imports.py

@@ -19,8 +19,6 @@
 from typing import Tuple
 
 from xdis.magics import canonic_python_version
-from xdis.opcodes import opcode_12897rust  # 3.13.0 0.4.0
-from xdis.opcodes import opcode_24481rust  # 3.13.0 0.4.0
 from xdis.opcodes import (
     opcode_10,
     opcode_11,
@@ -63,6 +61,9 @@
     opcode_312,
     opcode_313,
     opcode_314,
+    opcode_3531rust,
+    opcode_12897rust,
+    opcode_24481rust,
 )
 from xdis.opcodes.opcode_graal import (
     opcode_38graal,
@@ -193,6 +194,7 @@
     "3.12.0": opcode_312,
     "3.13.0rc3": opcode_313,
     "3.13.0Rust": opcode_24481rust,
+    "3.13.1Rust": opcode_3531rust,
     "3.14b3": opcode_314,
     "3.14.0": opcode_314,
     "3.14": opcode_314,

xdis/opcodes/__init__.py

@@ -68,7 +68,7 @@
     opcode_310pypy,
     opcode_311pypy,
 )
-from xdis.opcodes.opcode_rust import opcode_12897rust, opcode_24481rust
+from xdis.opcodes.opcode_rust import opcode_3531rust, opcode_12897rust, opcode_24481rust
 
 # from xdis.opcodes.opcode_graal import (
 #     opcode_310graal,
@@ -122,8 +122,8 @@
     "opcode_39pypy",
     # "opcode_310graal",
     # "opcode_311graal",
-    "opcode_38graal",
     # "opcode_312rust",
+    "opcode_3531rust",
     "opcode_12897rust",
     "opcode_24481rust",
 ]

xdis/opcodes/opcode_rust/base.py

@@ -239,7 +239,7 @@ def make_opcodes(loc: dict, magic_int: int):
         name_op_graal(loc,   "LOAD_ATTR")
     compare_op_graal(loc, "TEST_OP",           2, 1)  # test operator
     if magic_int in (24881,):
-        def_op_graal(loc,     "CopyItem")
+        def_op_graal(loc,     "COPY")
         binary_op_graal(loc, "BINARY_SUBCR")
     compare_op_graal(loc, "COMPARE_OP",        2, 1)  # Comparison operator
     if magic_int in (24881,):
@@ -256,10 +256,10 @@ def make_opcodes(loc: dict, magic_int: int):
 
     if magic_int in (24881,):
         def_op_graal(loc,     "GetLen")
-        def_op_graal(loc,     "CallIntrinsic1")
-        def_op_graal(loc,     "CallIntrinsic2")
-    def_op_graal(loc,     "Continue")
-    def_op_graal(loc,     "Break")
+        call_op_graal(loc,     "CallIntrinsic1")
+        call_op_graal(loc,     "CallIntrinsic2")
+    def_op_graal(loc,     "CONTINUE_LOOP")
+    def_op_graal(loc,     "BREAK_LOOP")
 
     # In contrast to CPython and others Rust does not seem to use relative jumps,
     # but only absolute jumps.
@@ -283,7 +283,7 @@ def make_opcodes(loc: dict, magic_int: int):
     call_op_graal(loc, "CALL_METHOD_KW")
     call_op_graal(loc, "CALL_METHOD_EX")
 
-    jrel_op_graal(loc, "FOR_ITER")
+    jabs_op_graal(loc, "FOR_ITER")
     def_op_graal(loc, "RETURN_VALUE")
     const_op_graal(loc, "RETURN_CONST")
     def_op_graal(loc, "YIELD")
@@ -292,7 +292,7 @@ def make_opcodes(loc: dict, magic_int: int):
         def_op_graal(loc, "RESUME", 0, 0)
 
     def_op_graal(loc, "SETUP_ANNOTATIONS")
-    jrel_op_graal(loc, "SETUP_LOOP", 0,  0, conditional=True)
+    jabs_op_graal(loc, "SETUP_LOOP", 0,  0, conditional=True)
     def_op_graal(loc, "SETUP_FINALLY", 0, 1)
 
     if magic_int in (12897,):