From b76176dc6e2175cd77065ba083e645585ea10eb0 Mon Sep 17 00:00:00 2001 From: hwdev Date: Mon, 16 Nov 2026 14:26:05 +0000 Subject: [PATCH] [mypyc] Generate lowered IR for abs() on native ints Generate lowered IR for native integer abs() with a generic primitive op, int_abs, that gets lowered via @lower_primitive_op in mypyc/lower/int_ops.py, kind of like vec_get_item_unsafe_op. Before, mypyc converted the value to a tagged int, called CPyTagged_Absolute and converted the result back. abs() of the minimum value of a signed type, such as abs(i8(-128)), now overflows like -x instead of raising ValueError. mypyc/doc/int_operations.rst says operations between native integer types don't check for overflow, and there's no run test for -x overflow either, so I didn't add one for abs(). --- mypyc/irbuild/specialize.py | 11 +++++++++++ mypyc/lower/int_ops.py | 23 +++++++++++++++++++++-- mypyc/primitives/int_ops.py | 10 ++++++++++ mypyc/test-data/lowering-int.test | 31 +++++++++++++++++++++++++++++++ 4 files changed, 73 insertions(+), 2 deletions(-) diff --git a/mypyc/irbuild/specialize.py b/mypyc/irbuild/specialize.py index d33f15a68beec..a73610844b281 100644 --- a/mypyc/irbuild/specialize.py +++ b/mypyc/irbuild/specialize.py @@ -147,6 +147,7 @@ from mypyc.primitives.float_ops import isinstance_float from mypyc.primitives.generic_ops import generic_setattr, setup_object from mypyc.primitives.int_ops import ( + int_abs_op, int_to_big_endian_op, int_to_bytes_op, int_to_little_endian_op, @@ -414,6 +415,16 @@ def translate_builtins_with_unary_dunder( return None +@specialize_function("builtins.abs") +def translate_abs(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None: + if len(expr.args) == 1 and expr.arg_kinds == [ARG_POS]: + arg_type = builder.node_type(expr.args[0]) + if is_fixed_width_rtype(arg_type): + arg = builder.accept(expr.args[0]) + return builder.builder.primitive_op(int_abs_op, [arg], expr.line, type_args=[arg_type]) + return None + + @specialize_function("builtins.len") def translate_len(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None: if len(expr.args) == 1 and expr.arg_kinds == [ARG_POS]: diff --git a/mypyc/lower/int_ops.py b/mypyc/lower/int_ops.py index adfb4c21e2de5..9c10cdfdd42cb 100644 --- a/mypyc/lower/int_ops.py +++ b/mypyc/lower/int_ops.py @@ -4,8 +4,8 @@ from typing import NamedTuple -from mypyc.ir.ops import Assign, BasicBlock, Branch, ComparisonOp, Register, Value -from mypyc.ir.rtypes import bool_rprimitive, is_short_int_rprimitive +from mypyc.ir.ops import Assign, BasicBlock, Branch, ComparisonOp, Integer, IntOp, Register, Value +from mypyc.ir.rtypes import bool_rprimitive, is_fixed_width_rtype, is_short_int_rprimitive from mypyc.irbuild.ll_builder import LowLevelIRBuilder from mypyc.lower.registry import lower_primitive_op from mypyc.primitives.int_ops import int_equal_, int_less_than_ @@ -111,3 +111,22 @@ def lower_int_gt(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Va @lower_primitive_op("int_ge") def lower_int_ge(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value: return compare_tagged(builder, args[0], args[1], ">=", line) + + +@lower_primitive_op("int_abs") +def lower_int_abs(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value: + x = args[0] + typ = x.type + assert is_fixed_width_rtype(typ) + if not typ.is_signed: + return x + result = Register(typ) + builder.add(Assign(result, x, line)) + neg, out = BasicBlock(), BasicBlock() + is_neg = builder.comparison_op(x, Integer(0, typ), ComparisonOp.SLT, line) + builder.add(Branch(is_neg, neg, out, Branch.BOOL)) + builder.activate_block(neg) + negated = builder.int_op(typ, Integer(0, typ), x, IntOp.SUB, line) + builder.add(Assign(result, negated, line)) + builder.goto_and_activate(out) + return result diff --git a/mypyc/primitives/int_ops.py b/mypyc/primitives/int_ops.py index 997b19e49693b..2bed5f1a5a912 100644 --- a/mypyc/primitives/int_ops.py +++ b/mypyc/primitives/int_ops.py @@ -19,6 +19,7 @@ ) from mypyc.ir.rtypes import ( RType, + RTypeVar, bit_rprimitive, bool_rprimitive, bytes_rprimitive, @@ -214,6 +215,15 @@ def int_unary_op(name: str, c_function_name: str) -> PrimitiveDescription: error_kind=ERR_NEVER, ) +# abs(x) for fixed-width x, lowered to inline IR +int_abs_op = custom_primitive_op( + name="int_abs", + arg_types=[RTypeVar(0)], + return_type=RTypeVar(0), + error_kind=ERR_NEVER, + type_params=[RTypeVar(0)], +) + # Primitives related to integer comparison operations: diff --git a/mypyc/test-data/lowering-int.test b/mypyc/test-data/lowering-int.test index 72c4a82dcaea3..a68fbc92ac40c 100644 --- a/mypyc/test-data/lowering-int.test +++ b/mypyc/test-data/lowering-int.test @@ -380,3 +380,34 @@ L5: L6: r11 = :: None return r11 + +[case testLowerI64Abs] +from mypy_extensions import i64 + +def f(x: i64) -> i64: + return abs(x) +[out] +def f(x): + x, r0 :: i64 + r1 :: bit + r2 :: i64 +L0: + r0 = x + r1 = x < 0 :: signed + if r1 goto L1 else goto L2 :: bool +L1: + r2 = 0 - x + r0 = r2 +L2: + return r0 + +[case testLowerU8Abs] +from mypy_extensions import u8 + +def f(x: u8) -> u8: + return abs(x) +[out] +def f(x): + x :: u8 +L0: + return x