Improve graal 3.12 bytecode handling

Author: rocky

xdis/lineoffsets_graal.py

@@ -82,11 +82,15 @@ def __init__(
         self.next_column = start_column
         self.next_line = start_line
         offset = 0
+        # print(f"XXX0 len: {n}") # debug
         while offset < n:
 
             # code[offset] is an int 0..255 in Python 3 when indexing bytes
+            # print(f"offset: {offset}") # debug
             op_byte = bytecode[offset]
+            # print(f"{opc.opname[op_byte]}") # debug
             op_len = arg_counts[op_byte] + 1
+            # print(f"op_len: {op_len}") # debug
 
             try:
                 start_line, start_column = self._next_line_and_column()

xdis/opcodes/opcode_312graal.py

@@ -551,7 +551,7 @@
 #
 # Pushes: the cell object
 #
-free_op_graal(loc, "LOAD_CLOSURE", 81, 1, 0, 1)
+free_op_graal(loc, "LOAD_CLOSURE", 0x52, 1, 0, 1)
 #
 # Reduces multiple stack items into an array of cell objects.
 #
@@ -560,7 +560,7 @@
 # Pushes: cell object array ({@code PCell[]})
 #
 def_op_graal(
-    loc, "CLOSURE_FROM_STACK", 82, 1
+    loc, "CLOSURE_FROM_STACK", 0x53, 1
 )  # , (oparg, followingArgs, withJump) -> oparg, 1)
 #
 # Creates a function object. The first immediate argument is an index to the constants array

xdis/unmarshal.py

@@ -29,7 +29,7 @@
 import io
 import marshal
 import sys
-from struct import unpack
+from struct import unpack, unpack_from
 from types import EllipsisType
 from typing import Any, Dict, Tuple, Union
 
@@ -147,6 +147,9 @@ def long(n: int) -> LongTypeForPython3:
     TYPE_UNKNOWN: "unknown",
 }
 
+# Used by graal
+JAVA_MARSHAL_SHIFT = 15
+JAVA_MARSHAL_BASE = 1 << JAVA_MARSHAL_SHIFT
 
 def compat_str(s: Union[str, bytes]) -> Union[str, bytes]:
     """
@@ -244,8 +247,8 @@ def t_graal_readArray(self, save_ref: bool, bytes_for_s: bool) -> tuple:
         # print(marshal_type)  # debug
 
         match marshal_type:
-            # case "B":
-            #     ret = tuple()
+            case "B":
+                ret = self.graal_readBigInteger()
             # case "b":
             #     return "OK"
             case "d":
@@ -269,6 +272,48 @@ def t_graal_readArray(self, save_ref: bool, bytes_for_s: bool) -> tuple:
             self.intern_objects.append(ret)
         return ret
 
+    def graal_readBigInteger(self):
+        """
+        Reads a marshaled big integer from the input stream.
+        """
+        negative = False
+        sz = self.graal_readInt() # Get the size in shorts
+        if sz < 0:
+            negative = True
+            sz = -sz
+
+        # size is in shorts, convert to size in bytes
+        sz *= 2
+
+        data = bytes([self.graal_readByte() for _ in range(sz)])
+
+        i = 0
+
+        # Read the first 2 bytes as a 16-bit signed integer (short)
+        # '>h' specifies big-endian signed short
+        digit = unpack_from('>h', data, i)[0]
+        i += 2
+
+        # Python int handles arbitrarily large numbers
+        result = digit
+
+        while i < sz:
+            # Calculate the power based on the number of shorts processed so far
+            power = i // 2
+            # Read the next 2 bytes as a 16-bit signed integer
+            digit = unpack_from('>h', data, i)[0]
+            i += 2
+
+            # In Python, int supports all these operations directly
+            # The Java code effectively reconstructs the number using base 2^16 (MARSHAL_BASE)
+            term = digit * (JAVA_MARSHAL_BASE ** power)
+            result += term
+
+        if negative:
+            return -result
+        else:
+            return result
+
     def graal_readByte(self) -> int:
         """
         Python equivalent of Python Graal's readBytes() from