[mypyc] handle negative_int_emit and Truncate op (#9050)

Related: mypyc/mypyc#734

Author: TH3CHARLie

mypyc/analysis.py

@@ -8,7 +8,8 @@
     Value, ControlOp,
     BasicBlock, OpVisitor, Assign, LoadInt, LoadErrorValue, RegisterOp, Goto, Branch, Return, Call,
     Environment, Box, Unbox, Cast, Op, Unreachable, TupleGet, TupleSet, GetAttr, SetAttr,
-    LoadStatic, InitStatic, PrimitiveOp, MethodCall, RaiseStandardError, CallC, LoadGlobal
+    LoadStatic, InitStatic, PrimitiveOp, MethodCall, RaiseStandardError, CallC, LoadGlobal,
+    Truncate
 )
 
 
@@ -198,6 +199,9 @@ def visit_raise_standard_error(self, op: RaiseStandardError) -> GenAndKill:
     def visit_call_c(self, op: CallC) -> GenAndKill:
         return self.visit_register_op(op)
 
+    def visit_truncate(self, op: Truncate) -> GenAndKill:
+        return self.visit_register_op(op)
+
     def visit_load_global(self, op: LoadGlobal) -> GenAndKill:
         return self.visit_register_op(op)
 

mypyc/codegen/emitfunc.py

@@ -11,7 +11,7 @@
     OpVisitor, Goto, Branch, Return, Assign, LoadInt, LoadErrorValue, GetAttr, SetAttr,
     LoadStatic, InitStatic, TupleGet, TupleSet, Call, IncRef, DecRef, Box, Cast, Unbox,
     BasicBlock, Value, MethodCall, PrimitiveOp, EmitterInterface, Unreachable, NAMESPACE_STATIC,
-    NAMESPACE_TYPE, NAMESPACE_MODULE, RaiseStandardError, CallC, LoadGlobal
+    NAMESPACE_TYPE, NAMESPACE_MODULE, RaiseStandardError, CallC, LoadGlobal, Truncate
 )
 from mypyc.ir.rtypes import RType, RTuple, is_int32_rprimitive, is_int64_rprimitive
 from mypyc.ir.func_ir import FuncIR, FuncDecl, FUNC_STATICMETHOD, FUNC_CLASSMETHOD
@@ -426,6 +426,12 @@ def visit_call_c(self, op: CallC) -> None:
         args = ', '.join(self.reg(arg) for arg in op.args)
         self.emitter.emit_line("{}{}({});".format(dest, op.function_name, args))
 
+    def visit_truncate(self, op: Truncate) -> None:
+        dest = self.reg(op)
+        value = self.reg(op.src)
+        # for C backend the generated code are straight assignments
+        self.emit_line("{} = {};".format(dest, value))
+
     def visit_load_global(self, op: LoadGlobal) -> None:
         dest = self.reg(op)
         ann = ''

mypyc/ir/ops.py

@@ -1183,6 +1183,40 @@ def accept(self, visitor: 'OpVisitor[T]') -> T:
         return visitor.visit_call_c(self)
 
 
+class Truncate(RegisterOp):
+    """truncate src: src_type to dst_type
+
+    Truncate a value from type with more bits to type with less bits
+
+    both src_type and dst_type should be non-reference counted integer types or bool
+    especially note that int_rprimitive is reference counted so should never be used here
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(self,
+                 src: Value,
+                 src_type: RType,
+                 dst_type: RType,
+                 line: int = -1) -> None:
+        super().__init__(line)
+        self.src = src
+        self.src_type = src_type
+        self.type = dst_type
+
+    def sources(self) -> List[Value]:
+        return [self.src]
+
+    def stolen(self) -> List[Value]:
+        return []
+
+    def to_str(self, env: Environment) -> str:
+        return env.format("%r = truncate %r: %r to %r", self, self.src, self.src_type, self.type)
+
+    def accept(self, visitor: 'OpVisitor[T]') -> T:
+        return visitor.visit_truncate(self)
+
+
 class LoadGlobal(RegisterOp):
     """Load a global variable/pointer"""
 
@@ -1307,6 +1341,10 @@ def visit_raise_standard_error(self, op: RaiseStandardError) -> T:
     def visit_call_c(self, op: CallC) -> T:
         raise NotImplementedError
 
+    @abstractmethod
+    def visit_truncate(self, op: Truncate) -> T:
+        raise NotImplementedError
+
     @abstractmethod
     def visit_load_global(self, op: LoadGlobal) -> T:
         raise NotImplementedError

mypyc/irbuild/ll_builder.py

@@ -19,7 +19,7 @@
 from mypyc.ir.ops import (
     BasicBlock, Environment, Op, LoadInt, Value, Register,
     Assign, Branch, Goto, Call, Box, Unbox, Cast, GetAttr,
-    LoadStatic, MethodCall, PrimitiveOp, OpDescription, RegisterOp, CallC,
+    LoadStatic, MethodCall, PrimitiveOp, OpDescription, RegisterOp, CallC, Truncate,
     RaiseStandardError, Unreachable, LoadErrorValue, LoadGlobal,
     NAMESPACE_TYPE, NAMESPACE_MODULE, NAMESPACE_STATIC,
 )
@@ -707,14 +707,19 @@ def call_c(self,
                 coerced.append(arg)
         target = self.add(CallC(desc.c_function_name, coerced, desc.return_type, desc.steals,
                                 desc.error_kind, line, var_arg_idx))
-        if result_type and not is_runtime_subtype(target.type, result_type):
+        if desc.truncated_type is None:
+            result = target
+        else:
+            truncate = self.add(Truncate(target, desc.return_type, desc.truncated_type))
+            result = truncate
+        if result_type and not is_runtime_subtype(result.type, result_type):
             if is_none_rprimitive(result_type):
                 # Special case None return. The actual result may actually be a bool
                 # and so we can't just coerce it.
-                target = self.none()
+                result = self.none()
             else:
-                target = self.coerce(target, result_type, line)
-        return target
+                result = self.coerce(target, result_type, line)
+        return result
 
     def matching_call_c(self,
                         candidates: List[CFunctionDescription],

mypyc/primitives/misc_ops.py

@@ -1,9 +1,9 @@
 """Miscellaneous primitive ops."""
 
-from mypyc.ir.ops import ERR_NEVER, ERR_MAGIC, ERR_FALSE
+from mypyc.ir.ops import ERR_NEVER, ERR_MAGIC, ERR_FALSE, ERR_NEG_INT
 from mypyc.ir.rtypes import (
     RTuple, none_rprimitive, bool_rprimitive, object_rprimitive, str_rprimitive,
-    int_rprimitive, dict_rprimitive
+    int_rprimitive, dict_rprimitive, c_int_rprimitive
 )
 from mypyc.primitives.registry import (
     name_ref_op, simple_emit, unary_op, func_op, custom_op, call_emit, name_emit,
@@ -150,11 +150,14 @@
     is_borrowed=True)
 
 # isinstance(obj, cls)
-func_op('builtins.isinstance',
-        arg_types=[object_rprimitive, object_rprimitive],
-        result_type=bool_rprimitive,
-        error_kind=ERR_MAGIC,
-        emit=call_negative_magic_emit('PyObject_IsInstance'))
+c_function_op(
+    name='builtins.isinstance',
+    arg_types=[object_rprimitive, object_rprimitive],
+    return_type=c_int_rprimitive,
+    c_function_name='PyObject_IsInstance',
+    error_kind=ERR_NEG_INT,
+    truncated_type=bool_rprimitive
+)
 
 # Faster isinstance(obj, cls) that only works with native classes and doesn't perform
 # type checking of the type argument.

mypyc/primitives/registry.py

@@ -47,6 +47,7 @@
                               ('arg_types', List[RType]),
                               ('return_type', RType),
                               ('var_arg_type', Optional[RType]),
+                              ('truncated_type', Optional[RType]),
                               ('c_function_name', str),
                               ('error_kind', int),
                               ('steals', StealsDescription),
@@ -350,6 +351,7 @@ def c_method_op(name: str,
                 c_function_name: str,
                 error_kind: int,
                 var_arg_type: Optional[RType] = None,
+                truncated_type: Optional[RType] = None,
                 steals: StealsDescription = False,
                 priority: int = 1) -> CFunctionDescription:
     """Define a c function call op that replaces a method call.
@@ -363,11 +365,14 @@ def c_method_op(name: str,
         c_function_name: name of the C function to call
         error_kind: how errors are represented in the result (one of ERR_*)
         var_arg_type: type of all variable arguments
+        truncated_type: type to truncated to(See Truncate for info)
+                        if it's defined both return_type and it should be non-referenced
+                        integer types or bool type
         steals: description of arguments that this steals (ref count wise)
         priority: if multiple ops match, the one with the highest priority is picked
     """
     ops = c_method_call_ops.setdefault(name, [])
-    desc = CFunctionDescription(name, arg_types, return_type, var_arg_type,
+    desc = CFunctionDescription(name, arg_types, return_type, var_arg_type, truncated_type,
                                 c_function_name, error_kind, steals, priority)
     ops.append(desc)
     return desc
@@ -379,6 +384,7 @@ def c_function_op(name: str,
                   c_function_name: str,
                   error_kind: int,
                   var_arg_type: Optional[RType] = None,
+                  truncated_type: Optional[RType] = None,
                   steals: StealsDescription = False,
                   priority: int = 1) -> CFunctionDescription:
     """Define a c function call op that replaces a function call.
@@ -392,7 +398,7 @@ def c_function_op(name: str,
         arg_types: positional argument types for which this applies
     """
     ops = c_function_ops.setdefault(name, [])
-    desc = CFunctionDescription(name, arg_types, return_type, var_arg_type,
+    desc = CFunctionDescription(name, arg_types, return_type, var_arg_type, truncated_type,
                                 c_function_name, error_kind, steals, priority)
     ops.append(desc)
     return desc
@@ -404,6 +410,7 @@ def c_binary_op(name: str,
                 c_function_name: str,
                 error_kind: int,
                 var_arg_type: Optional[RType] = None,
+                truncated_type: Optional[RType] = None,
                 steals: StealsDescription = False,
                 priority: int = 1) -> CFunctionDescription:
     """Define a c function call op for a binary operation.
@@ -414,7 +421,7 @@ def c_binary_op(name: str,
     are expected.
     """
     ops = c_binary_ops.setdefault(name, [])
-    desc = CFunctionDescription(name, arg_types, return_type, var_arg_type,
+    desc = CFunctionDescription(name, arg_types, return_type, var_arg_type, truncated_type,
                             c_function_name, error_kind, steals, priority)
     ops.append(desc)
     return desc
@@ -425,12 +432,13 @@ def c_custom_op(arg_types: List[RType],
                 c_function_name: str,
                 error_kind: int,
                 var_arg_type: Optional[RType] = None,
+                truncated_type: Optional[RType] = None,
                 steals: StealsDescription = False) -> CFunctionDescription:
     """Create a one-off CallC op that can't be automatically generated from the AST.
 
     Most arguments are similar to c_method_op().
     """
-    return CFunctionDescription('<custom>', arg_types, return_type, var_arg_type,
+    return CFunctionDescription('<custom>', arg_types, return_type, var_arg_type, truncated_type,
                             c_function_name, error_kind, steals, 0)
 
 
@@ -439,6 +447,7 @@ def c_unary_op(name: str,
                return_type: RType,
                c_function_name: str,
                error_kind: int,
+               truncated_type: Optional[RType] = None,
                steals: StealsDescription = False,
                priority: int = 1) -> CFunctionDescription:
     """Define a c function call op for an unary operation.
@@ -449,7 +458,7 @@ def c_unary_op(name: str,
     is expected.
     """
     ops = c_unary_ops.setdefault(name, [])
-    desc = CFunctionDescription(name, [arg_type], return_type, None,
+    desc = CFunctionDescription(name, [arg_type], return_type, None, truncated_type,
                             c_function_name, error_kind, steals, priority)
     ops.append(desc)
     return desc

mypyc/test-data/irbuild-basic.test

@@ -1502,19 +1502,21 @@ def main() -> None:
 def foo(x):
     x :: union[int, str]
     r0 :: object
-    r1 :: bool
-    r2 :: __main__.B
-    r3 :: __main__.A
+    r1 :: int32
+    r2 :: bool
+    r3 :: __main__.B
+    r4 :: __main__.A
 L0:
     r0 = int
-    r1 = isinstance x, r0
-    if r1 goto L1 else goto L2 :: bool
+    r1 = PyObject_IsInstance(x, r0)
+    r2 = truncate r1: int32 to builtins.bool
+    if r2 goto L1 else goto L2 :: bool
 L1:
-    r2 = B()
-    return r2
-L2:
-    r3 = A()
+    r3 = B()
     return r3
+L2:
+    r4 = A()
+    return r4
 def main():
     r0 :: short_int
     r1 :: object

mypyc/test-data/irbuild-optional.test

@@ -299,25 +299,27 @@ def f(x: Union[int, A]) -> int:
 def f(x):
     x :: union[int, __main__.A]
     r0 :: object
-    r1 :: bool
-    r2 :: int
-    r3 :: short_int
-    r4 :: int
-    r5 :: __main__.A
-    r6 :: int
+    r1 :: int32
+    r2 :: bool
+    r3 :: int
+    r4 :: short_int
+    r5 :: int
+    r6 :: __main__.A
+    r7 :: int
 L0:
     r0 = int
-    r1 = isinstance x, r0
-    if r1 goto L1 else goto L2 :: bool
+    r1 = PyObject_IsInstance(x, r0)
+    r2 = truncate r1: int32 to builtins.bool
+    if r2 goto L1 else goto L2 :: bool
 L1:
-    r2 = unbox(int, x)
-    r3 = 1
-    r4 = CPyTagged_Add(r2, r3)
-    return r4
+    r3 = unbox(int, x)
+    r4 = 1
+    r5 = CPyTagged_Add(r3, r4)
+    return r5
 L2:
-    r5 = cast(__main__.A, x)
-    r6 = r5.a
-    return r6
+    r6 = cast(__main__.A, x)
+    r7 = r6.a
+    return r7
 L3:
     unreachable