Add support for 13.2 bytecode

Signed-off-by: Greg Bonik <gbonik@nvidia.com>

Author: gbonik

src/cuda/tile/_bytecode/__init__.py

@@ -12,5 +12,6 @@
 from .code_builder import CodeBuilder, Value  # noqa: F401
 from .float import float_to_bits, float_bit_size  # noqa: F401
 from .encodings import *  # noqa: F401 F403
+from .version import BytecodeVersion  # noqa: F401
 
 DYNAMIC_SHAPE = -1 << 63   # INT64_MIN

src/cuda/tile/_bytecode/code_builder.py

@@ -11,6 +11,7 @@
 from .constant import ConstantTable
 from .debug_info import DebugAttrId
 from .type import TypeId, encode_typeid
+from .version import BytecodeVersion
 
 
 @dataclass
@@ -57,6 +58,7 @@ def done(self) -> Tuple[Value, ...]:
 @dataclass
 class CodeBuilder:
     buf: bytearray
+    version: BytecodeVersion
     string_table: StringTable
     constant_table: ConstantTable
     debug_attr_per_op: List[DebugAttrId]

src/cuda/tile/_bytecode/encodings.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) <2025> NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) <2026> NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -12,6 +12,7 @@
     encode_unsized_variadic_operands, encode_sized_variadic_operands, encode_operand
 )
 from .type import encode_typeid, encode_sized_typeid_seq, TypeId
+from .version import BytecodeVersion
 
 
 class AtomicRMWMode(enum.Enum):
@@ -200,6 +201,23 @@ def encode_AssumeOp(
     return code_builder.new_op()
 
 
+def encode_Atan2Op(  # since 13.2
+    code_builder: CodeBuilder,
+    result_type: TypeId,  # since 13.2
+    x: Value,  # since 13.2
+    y: Value,  # since 13.2
+) -> Value:
+    _buf = code_builder.buf
+    # Opcode
+    encode_varint(110, _buf)
+    # Result types
+    encode_typeid(result_type, _buf)
+    # Operands
+    encode_operand(x, _buf)
+    encode_operand(y, _buf)
+    return code_builder.new_op()
+
+
 def encode_AtomicCASTkoOp(
     code_builder: CodeBuilder,
     result_type: TypeId,
@@ -676,12 +694,18 @@ def encode_ForOp(
     upperBound: Value,
     step: Value,
     initValues: Sequence[Value],
+    unsignedCmp: bool,  # since 13.2
 ) -> NestedBlockBuilder:
     _buf = code_builder.buf
     # Opcode
     encode_varint(41, _buf)
     # Variadic result types
     encode_sized_typeid_seq(result_types, _buf)
+    # Flags
+    _flag_bits = bool(unsignedCmp)
+    assert _flag_bits < 1 or code_builder.version >= BytecodeVersion.V_13_2
+    if code_builder.version >= BytecodeVersion.V_13_2:
+        encode_varint(_flag_bits, _buf)
     # Operands
     encode_varint(3 + len(initValues), _buf)
     encode_operand(lowerBound, _buf)
@@ -1243,12 +1267,18 @@ def encode_NegIOp(
     code_builder: CodeBuilder,
     result_type: TypeId,
     source: Value,
+    overflow: IntegerOverflow,  # since 13.2
 ) -> Value:
     _buf = code_builder.buf
     # Opcode
     encode_varint(80, _buf)
     # Result types
     encode_typeid(result_type, _buf)
+    # Attributes
+    if code_builder.version >= BytecodeVersion.V_13_2:
+        code_builder.encode_opattr_enum(IntegerOverflow, overflow)
+    else:
+        assert overflow == IntegerOverflow.NONE
     # Operands
     encode_operand(source, _buf)
     return code_builder.new_op()
@@ -1323,22 +1353,37 @@ def encode_PowOp(
     return code_builder.new_op()
 
 
-def encode_PrintOp(
+def encode_PrintTkoOp(
     code_builder: CodeBuilder,
+    result_token_type: Optional[TypeId],  # since 13.2
     args: Sequence[Value],
+    token: Optional[Value],  # since 13.2
     str: str,
-) -> None:
+) -> Optional[Value]:
     _buf = code_builder.buf
     # Opcode
     encode_varint(85, _buf)
     # Variadic result types
-    encode_sized_typeid_seq((), _buf)
+    result_types = []
+    if code_builder.version >= BytecodeVersion.V_13_2:
+        result_token_idx = len(result_types)
+        result_types.append(result_token_type)
+    else:
+        assert result_token_type is None
+        result_token_idx = None
+    encode_sized_typeid_seq(result_types, _buf)
+    # Flags
+    _flag_bits = (token is not None)
+    assert _flag_bits < 1 or code_builder.version >= BytecodeVersion.V_13_2
+    if code_builder.version >= BytecodeVersion.V_13_2:
+        encode_varint(_flag_bits, _buf)
     # Attributes
     code_builder.encode_opattr_str(str)
     # Operands
-    encode_varint(len(args), _buf)
-    encode_unsized_variadic_operands(args, _buf)
-    return code_builder.new_op(0)
+    encode_sized_variadic_operands(args, _buf)
+    encode_optional_operand(token, _buf)
+    results = code_builder.new_op(len(result_types))
+    return None if result_token_idx is None else results[result_token_idx]
 
 
 def encode_PtrToIntOp(
@@ -1726,12 +1771,18 @@ def encode_TanHOp(
     code_builder: CodeBuilder,
     result_type: TypeId,
     source: Value,
+    rounding_mode: RoundingMode,  # since 13.2
 ) -> Value:
     _buf = code_builder.buf
     # Opcode
     encode_varint(106, _buf)
     # Result types
     encode_typeid(result_type, _buf)
+    # Attributes
+    if code_builder.version >= BytecodeVersion.V_13_2:
+        code_builder.encode_opattr_enum(RoundingMode, rounding_mode)
+    else:
+        assert rounding_mode == RoundingMode.FULL
     # Operands
     encode_operand(source, _buf)
     return code_builder.new_op()
@@ -1818,6 +1869,7 @@ def encode_YieldOp(
     'encode_AndIOp',
     'encode_AssertOp',
     'encode_AssumeOp',
+    'encode_Atan2Op',
     'encode_AtomicCASTkoOp',
     'encode_AtomicRMWTkoOp',
     'encode_BitcastOp',
@@ -1878,7 +1930,7 @@ def encode_YieldOp(
     'encode_OrIOp',
     'encode_PermuteOp',
     'encode_PowOp',
-    'encode_PrintOp',
+    'encode_PrintTkoOp',
     'encode_PtrToIntOp',
     'encode_PtrToPtrOp',
     'encode_ReduceOp',

src/cuda/tile/_bytecode/version.py

@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: Copyright (c) <2026> NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import enum
+
+
+class BytecodeVersion(enum.IntEnum):
+    V_13_1 = 130100
+    V_13_2 = 130200
+
+    def major(self) -> int:
+        return self._value_ // 10000
+
+    def minor(self) -> int:
+        return (self._value_ // 100) % 100
+
+    def tag(self) -> int:
+        return self._value_ % 100

src/cuda/tile/_bytecode/writer.py

@@ -12,9 +12,7 @@
 from .constant import ConstantTable
 from .debug_info import DebugAttrId, DebugAttrTable
 from .type import TypeTable, TypeId, encode_typeid
-
-
-_BYTECODE_VERSION = (13, 1, 0)
+from .version import BytecodeVersion
 
 
 class FunctionBuilder(NamedTuple):
@@ -44,7 +42,7 @@ def is_defined(self, global_name: str):
 
 
 class BytecodeWriter:
-    def __init__(self, buf: bytearray):
+    def __init__(self, buf: bytearray, version: BytecodeVersion):
         self._num_functions = 0
         self.debug_info = []
         self._buf = buf
@@ -53,6 +51,7 @@ def __init__(self, buf: bytearray):
         self._constant_table = ConstantTable()
         self._type_table = TypeTable()
         self._global_section = GlobalSection(self._string_table, self._constant_table)
+        self.version = version
 
     @property
     def debug_attr_table(self) -> DebugAttrTable:
@@ -90,6 +89,7 @@ def function(self,
             make_entry_hints(hints).encode_tagged(self._string_table, self._buf)
 
         builder = CodeBuilder(buf=bytearray(),
+                              version=self.version,
                               string_table=self._string_table,
                               constant_table=self._constant_table,
                               debug_attr_per_op=self.debug_info[-1])
@@ -99,12 +99,13 @@ def function(self,
 
 
 @contextmanager
-def write_bytecode(num_functions: int, buf: bytearray) -> Iterator[BytecodeWriter]:
-    _write_header(buf)
+def write_bytecode(num_functions: int, buf: bytearray,
+                   version: BytecodeVersion) -> Iterator[BytecodeWriter]:
+    _write_header(buf, version)
 
     with _section(_Section.Func, 8, buf) as section_buf:
         encode_varint(num_functions, section_buf)
-        w = BytecodeWriter(section_buf)
+        w = BytecodeWriter(section_buf, version)
         yield w
         assert w._num_functions == num_functions
 
@@ -124,12 +125,11 @@ def write_bytecode(num_functions: int, buf: bytearray) -> Iterator[BytecodeWrite
     buf.append(_Section.EndOfBytecode._value_)
 
 
-def _write_header(buf: bytearray):
+def _write_header(buf: bytearray, version: BytecodeVersion):
     buf.extend(b"\x7fTileIR\x00")  # magic number
-    major, minor, tag = _BYTECODE_VERSION
-    buf.append(major)
-    buf.append(minor)
-    buf.extend(tag.to_bytes(2, "little"))
+    buf.append(version.major())
+    buf.append(version.minor())
+    buf.extend(version.tag().to_bytes(2, "little"))
 
 
 class _Section(enum.IntEnum):