class TestGenerateFunction(unittest.TestCase): def setUp(self) -> None: self.var = Var('arg') self.arg = RuntimeArg('arg', int_rprimitive) self.env = Environment() self.reg = self.env.add_local(self.var, int_rprimitive) self.block = BasicBlock(0) def test_simple(self) -> None: self.block.ops.append(Return(self.reg)) fn = FuncIR( FuncDecl('myfunc', None, 'mod', FuncSignature([self.arg], int_rprimitive)), [self.block], self.env) value_names = generate_names_for_env(self.env) emitter = Emitter(EmitterContext(NameGenerator([['mod']])), self.env, value_names) generate_native_function(fn, emitter, 'prog.py', 'prog', optimize_int=False) result = emitter.fragments assert_string_arrays_equal([ 'CPyTagged CPyDef_myfunc(CPyTagged cpy_r_arg) {\n', 'CPyL0: ;\n', ' return cpy_r_arg;\n', '}\n', ], result, msg='Generated code invalid') def test_register(self) -> None: op = LoadInt(5) self.block.ops.append(op) self.env.add_op(op) fn = FuncIR( FuncDecl('myfunc', None, 'mod', FuncSignature([self.arg], list_rprimitive)), [self.block], self.env) value_names = generate_names_for_env(self.env) emitter = Emitter(EmitterContext(NameGenerator([['mod']])), self.env, value_names) generate_native_function(fn, emitter, 'prog.py', 'prog', optimize_int=False) result = emitter.fragments assert_string_arrays_equal([ 'PyObject *CPyDef_myfunc(CPyTagged cpy_r_arg) {\n', ' CPyTagged cpy_r_i0;\n', 'CPyL0: ;\n', ' cpy_r_i0 = 10;\n', '}\n', ], result, msg='Generated code invalid')
def split_blocks_at_uninits(env: Environment, blocks: List[BasicBlock], pre_must_defined: 'AnalysisDict[Value]') -> List[BasicBlock]: new_blocks = [] # type: List[BasicBlock] # First split blocks on ops that may raise. for block in blocks: ops = block.ops block.ops = [] cur_block = block new_blocks.append(cur_block) for i, op in enumerate(ops): defined = pre_must_defined[block, i] for src in op.unique_sources(): # If a register operand is not guaranteed to be # initialized is an operand to something other than a # check that it is defined, insert a check. # Note that for register operand in a LoadAddress op, # we should be able to use it without initialization # as we may need to use its address to update itself if (isinstance(src, Register) and src not in defined and not (isinstance(op, Branch) and op.op == Branch.IS_ERROR) and not isinstance(op, LoadAddress)): new_block, error_block = BasicBlock(), BasicBlock() new_block.error_handler = error_block.error_handler = cur_block.error_handler new_blocks += [error_block, new_block] env.vars_needing_init.add(src) cur_block.ops.append(Branch(src, true_label=error_block, false_label=new_block, op=Branch.IS_ERROR, line=op.line)) raise_std = RaiseStandardError( RaiseStandardError.UNBOUND_LOCAL_ERROR, "local variable '{}' referenced before assignment".format(src.name), op.line) env.add_op(raise_std) error_block.ops.append(raise_std) error_block.ops.append(Unreachable()) cur_block = new_block cur_block.ops.append(op) return new_blocks
class LowLevelIRBuilder: def __init__( self, current_module: str, mapper: Mapper, ) -> None: self.current_module = current_module self.mapper = mapper self.environment = Environment() self.blocks = [] # type: List[BasicBlock] # Stack of except handler entry blocks self.error_handlers = [None] # type: List[Optional[BasicBlock]] # Basic operations def add(self, op: Op) -> Value: """Add an op.""" assert not self.blocks[-1].terminated, "Can't add to finished block" self.blocks[-1].ops.append(op) if isinstance(op, RegisterOp): self.environment.add_op(op) return op def goto(self, target: BasicBlock) -> None: """Add goto to a basic block.""" if not self.blocks[-1].terminated: self.add(Goto(target)) def activate_block(self, block: BasicBlock) -> None: """Add a basic block and make it the active one (target of adds).""" if self.blocks: assert self.blocks[-1].terminated block.error_handler = self.error_handlers[-1] self.blocks.append(block) def goto_and_activate(self, block: BasicBlock) -> None: """Add goto a block and make it the active block.""" self.goto(block) self.activate_block(block) def push_error_handler(self, handler: Optional[BasicBlock]) -> None: self.error_handlers.append(handler) def pop_error_handler(self) -> Optional[BasicBlock]: return self.error_handlers.pop() def alloc_temp(self, type: RType) -> Register: return self.environment.add_temp(type) # Type conversions def box(self, src: Value) -> Value: if src.type.is_unboxed: return self.add(Box(src)) else: return src def unbox_or_cast(self, src: Value, target_type: RType, line: int) -> Value: if target_type.is_unboxed: return self.add(Unbox(src, target_type, line)) else: return self.add(Cast(src, target_type, line)) def coerce(self, src: Value, target_type: RType, line: int, force: bool = False) -> Value: """Generate a coercion/cast from one type to other (only if needed). For example, int -> object boxes the source int; int -> int emits nothing; object -> int unboxes the object. All conversions preserve object value. If force is true, always generate an op (even if it is just an assignment) so that the result will have exactly target_type as the type. Returns the register with the converted value (may be same as src). """ if src.type.is_unboxed and not target_type.is_unboxed: return self.box(src) if ((src.type.is_unboxed and target_type.is_unboxed) and not is_runtime_subtype(src.type, target_type)): # To go from one unboxed type to another, we go through a boxed # in-between value, for simplicity. tmp = self.box(src) return self.unbox_or_cast(tmp, target_type, line) if ((not src.type.is_unboxed and target_type.is_unboxed) or not is_subtype(src.type, target_type)): return self.unbox_or_cast(src, target_type, line) elif force: tmp = self.alloc_temp(target_type) self.add(Assign(tmp, src)) return tmp return src # Attribute access def get_attr(self, obj: Value, attr: str, result_type: RType, line: int) -> Value: """Get a native or Python attribute of an object.""" if (isinstance(obj.type, RInstance) and obj.type.class_ir.is_ext_class and obj.type.class_ir.has_attr(attr)): return self.add(GetAttr(obj, attr, line)) elif isinstance(obj.type, RUnion): return self.union_get_attr(obj, obj.type, attr, result_type, line) else: return self.py_get_attr(obj, attr, line) def union_get_attr(self, obj: Value, rtype: RUnion, attr: str, result_type: RType, line: int) -> Value: """Get an attribute of an object with a union type.""" def get_item_attr(value: Value) -> Value: return self.get_attr(value, attr, result_type, line) return self.decompose_union_helper(obj, rtype, result_type, get_item_attr, line) def py_get_attr(self, obj: Value, attr: str, line: int) -> Value: """Get a Python attribute (slow). Prefer get_attr() which generates optimized code for native classes. """ key = self.load_static_unicode(attr) return self.add(PrimitiveOp([obj, key], py_getattr_op, line)) # isinstance() checks def isinstance_helper(self, obj: Value, class_irs: List[ClassIR], line: int) -> Value: """Fast path for isinstance() that checks against a list of native classes.""" if not class_irs: return self.primitive_op(false_op, [], line) ret = self.isinstance_native(obj, class_irs[0], line) for class_ir in class_irs[1:]: def other() -> Value: return self.isinstance_native(obj, class_ir, line) ret = self.shortcircuit_helper('or', bool_rprimitive, lambda: ret, other, line) return ret def isinstance_native(self, obj: Value, class_ir: ClassIR, line: int) -> Value: """Fast isinstance() check for a native class. If there are three or fewer concrete (non-trait) classes among the class and all its children, use even faster type comparison checks `type(obj) is typ`. """ concrete = all_concrete_classes(class_ir) if concrete is None or len(concrete) > FAST_ISINSTANCE_MAX_SUBCLASSES + 1: return self.primitive_op(fast_isinstance_op, [obj, self.get_native_type(class_ir)], line) if not concrete: # There can't be any concrete instance that matches this. return self.primitive_op(false_op, [], line) type_obj = self.get_native_type(concrete[0]) ret = self.primitive_op(type_is_op, [obj, type_obj], line) for c in concrete[1:]: def other() -> Value: return self.primitive_op(type_is_op, [obj, self.get_native_type(c)], line) ret = self.shortcircuit_helper('or', bool_rprimitive, lambda: ret, other, line) return ret # Calls def py_call(self, function: Value, arg_values: List[Value], line: int, arg_kinds: Optional[List[int]] = None, arg_names: Optional[Sequence[Optional[str]]] = None) -> Value: """Call a Python function (non-native and slow). Use py_call_op or py_call_with_kwargs_op for Python function call. """ # If all arguments are positional, we can use py_call_op. if (arg_kinds is None) or all(kind == ARG_POS for kind in arg_kinds): return self.primitive_op(py_call_op, [function] + arg_values, line) # Otherwise fallback to py_call_with_kwargs_op. assert arg_names is not None pos_arg_values = [] kw_arg_key_value_pairs = [] # type: List[DictEntry] star_arg_values = [] for value, kind, name in zip(arg_values, arg_kinds, arg_names): if kind == ARG_POS: pos_arg_values.append(value) elif kind == ARG_NAMED: assert name is not None key = self.load_static_unicode(name) kw_arg_key_value_pairs.append((key, value)) elif kind == ARG_STAR: star_arg_values.append(value) elif kind == ARG_STAR2: # NOTE: mypy currently only supports a single ** arg, but python supports multiple. # This code supports multiple primarily to make the logic easier to follow. kw_arg_key_value_pairs.append((None, value)) else: assert False, ("Argument kind should not be possible:", kind) if len(star_arg_values) == 0: # We can directly construct a tuple if there are no star args. pos_args_tuple = self.primitive_op(new_tuple_op, pos_arg_values, line) else: # Otherwise we construct a list and call extend it with the star args, since tuples # don't have an extend method. pos_args_list = self.primitive_op(new_list_op, pos_arg_values, line) for star_arg_value in star_arg_values: self.call_c(list_extend_op, [pos_args_list, star_arg_value], line) pos_args_tuple = self.call_c(list_tuple_op, [pos_args_list], line) kw_args_dict = self.make_dict(kw_arg_key_value_pairs, line) return self.primitive_op( py_call_with_kwargs_op, [function, pos_args_tuple, kw_args_dict], line) def py_method_call(self, obj: Value, method_name: str, arg_values: List[Value], line: int, arg_kinds: Optional[List[int]], arg_names: Optional[Sequence[Optional[str]]]) -> Value: """Call a Python method (non-native and slow).""" if (arg_kinds is None) or all(kind == ARG_POS for kind in arg_kinds): method_name_reg = self.load_static_unicode(method_name) return self.primitive_op(py_method_call_op, [obj, method_name_reg] + arg_values, line) else: method = self.py_get_attr(obj, method_name, line) return self.py_call(method, arg_values, line, arg_kinds=arg_kinds, arg_names=arg_names) def call(self, decl: FuncDecl, args: Sequence[Value], arg_kinds: List[int], arg_names: Sequence[Optional[str]], line: int) -> Value: """Call a native function.""" # Normalize args to positionals. args = self.native_args_to_positional( args, arg_kinds, arg_names, decl.sig, line) return self.add(Call(decl, args, line)) def native_args_to_positional(self, args: Sequence[Value], arg_kinds: List[int], arg_names: Sequence[Optional[str]], sig: FuncSignature, line: int) -> List[Value]: """Prepare arguments for a native call. Given args/kinds/names and a target signature for a native call, map keyword arguments to their appropriate place in the argument list, fill in error values for unspecified default arguments, package arguments that will go into *args/**kwargs into a tuple/dict, and coerce arguments to the appropriate type. """ sig_arg_kinds = [arg.kind for arg in sig.args] sig_arg_names = [arg.name for arg in sig.args] formal_to_actual = map_actuals_to_formals(arg_kinds, arg_names, sig_arg_kinds, sig_arg_names, lambda n: AnyType(TypeOfAny.special_form)) # Flatten out the arguments, loading error values for default # arguments, constructing tuples/dicts for star args, and # coercing everything to the expected type. output_args = [] for lst, arg in zip(formal_to_actual, sig.args): output_arg = None if arg.kind == ARG_STAR: output_arg = self.primitive_op(new_tuple_op, [args[i] for i in lst], line) elif arg.kind == ARG_STAR2: dict_entries = [(self.load_static_unicode(cast(str, arg_names[i])), args[i]) for i in lst] output_arg = self.make_dict(dict_entries, line) elif not lst: output_arg = self.add(LoadErrorValue(arg.type, is_borrowed=True)) else: output_arg = args[lst[0]] output_args.append(self.coerce(output_arg, arg.type, line)) return output_args def gen_method_call(self, base: Value, name: str, arg_values: List[Value], result_type: Optional[RType], line: int, arg_kinds: Optional[List[int]] = None, arg_names: Optional[List[Optional[str]]] = None) -> Value: """Generate either a native or Python method call.""" # If arg_kinds contains values other than arg_pos and arg_named, then fallback to # Python method call. if (arg_kinds is not None and not all(kind in (ARG_POS, ARG_NAMED) for kind in arg_kinds)): return self.py_method_call(base, name, arg_values, base.line, arg_kinds, arg_names) # If the base type is one of ours, do a MethodCall if (isinstance(base.type, RInstance) and base.type.class_ir.is_ext_class and not base.type.class_ir.builtin_base): if base.type.class_ir.has_method(name): decl = base.type.class_ir.method_decl(name) if arg_kinds is None: assert arg_names is None, "arg_kinds not present but arg_names is" arg_kinds = [ARG_POS for _ in arg_values] arg_names = [None for _ in arg_values] else: assert arg_names is not None, "arg_kinds present but arg_names is not" # Normalize args to positionals. assert decl.bound_sig arg_values = self.native_args_to_positional( arg_values, arg_kinds, arg_names, decl.bound_sig, line) return self.add(MethodCall(base, name, arg_values, line)) elif base.type.class_ir.has_attr(name): function = self.add(GetAttr(base, name, line)) return self.py_call(function, arg_values, line, arg_kinds=arg_kinds, arg_names=arg_names) elif isinstance(base.type, RUnion): return self.union_method_call(base, base.type, name, arg_values, result_type, line, arg_kinds, arg_names) # Try to do a special-cased method call if not arg_kinds or arg_kinds == [ARG_POS] * len(arg_values): target = self.translate_special_method_call(base, name, arg_values, result_type, line) if target: return target # Fall back to Python method call return self.py_method_call(base, name, arg_values, line, arg_kinds, arg_names) def union_method_call(self, base: Value, obj_type: RUnion, name: str, arg_values: List[Value], return_rtype: Optional[RType], line: int, arg_kinds: Optional[List[int]], arg_names: Optional[List[Optional[str]]]) -> Value: """Generate a method call with a union type for the object.""" # Union method call needs a return_rtype for the type of the output register. # If we don't have one, use object_rprimitive. return_rtype = return_rtype or object_rprimitive def call_union_item(value: Value) -> Value: return self.gen_method_call(value, name, arg_values, return_rtype, line, arg_kinds, arg_names) return self.decompose_union_helper(base, obj_type, return_rtype, call_union_item, line) # Loading various values def none(self) -> Value: """Load unboxed None value (type: none_rprimitive).""" return self.add(PrimitiveOp([], none_op, line=-1)) def none_object(self) -> Value: """Load Python None value (type: object_rprimitive).""" return self.add(PrimitiveOp([], none_object_op, line=-1)) def literal_static_name(self, value: Union[int, float, complex, str, bytes]) -> str: return STATIC_PREFIX + self.mapper.literal_static_name(self.current_module, value) def load_static_int(self, value: int) -> Value: """Loads a static integer Python 'int' object into a register.""" if abs(value) > MAX_LITERAL_SHORT_INT: identifier = self.literal_static_name(value) return self.add(LoadGlobal(int_rprimitive, identifier, ann=value)) else: return self.add(LoadInt(value)) def load_static_float(self, value: float) -> Value: """Loads a static float value into a register.""" identifier = self.literal_static_name(value) return self.add(LoadGlobal(float_rprimitive, identifier, ann=value)) def load_static_bytes(self, value: bytes) -> Value: """Loads a static bytes value into a register.""" identifier = self.literal_static_name(value) return self.add(LoadGlobal(object_rprimitive, identifier, ann=value)) def load_static_complex(self, value: complex) -> Value: """Loads a static complex value into a register.""" identifier = self.literal_static_name(value) return self.add(LoadGlobal(object_rprimitive, identifier, ann=value)) def load_static_unicode(self, value: str) -> Value: """Loads a static unicode value into a register. This is useful for more than just unicode literals; for example, method calls also require a PyObject * form for the name of the method. """ identifier = self.literal_static_name(value) return self.add(LoadGlobal(str_rprimitive, identifier, ann=value)) def load_static_checked(self, typ: RType, identifier: str, module_name: Optional[str] = None, namespace: str = NAMESPACE_STATIC, line: int = -1, error_msg: Optional[str] = None) -> Value: if error_msg is None: error_msg = "name '{}' is not defined".format(identifier) ok_block, error_block = BasicBlock(), BasicBlock() value = self.add(LoadStatic(typ, identifier, module_name, namespace, line=line)) self.add(Branch(value, error_block, ok_block, Branch.IS_ERROR, rare=True)) self.activate_block(error_block) self.add(RaiseStandardError(RaiseStandardError.NAME_ERROR, error_msg, line)) self.add(Unreachable()) self.activate_block(ok_block) return value def load_module(self, name: str) -> Value: return self.add(LoadStatic(object_rprimitive, name, namespace=NAMESPACE_MODULE)) def get_native_type(self, cls: ClassIR) -> Value: """Load native type object.""" fullname = '%s.%s' % (cls.module_name, cls.name) return self.load_native_type_object(fullname) def load_native_type_object(self, fullname: str) -> Value: module, name = fullname.rsplit('.', 1) return self.add(LoadStatic(object_rprimitive, name, module, NAMESPACE_TYPE)) # Other primitive operations def primitive_op(self, desc: OpDescription, args: List[Value], line: int) -> Value: assert desc.result_type is not None coerced = [] for i, arg in enumerate(args): formal_type = self.op_arg_type(desc, i) arg = self.coerce(arg, formal_type, line) coerced.append(arg) target = self.add(PrimitiveOp(coerced, desc, line)) return target def matching_primitive_op(self, candidates: List[OpDescription], args: List[Value], line: int, result_type: Optional[RType] = None) -> Optional[Value]: # Find the highest-priority primitive op that matches. matching = None # type: Optional[OpDescription] for desc in candidates: if len(desc.arg_types) != len(args): continue if all(is_subtype(actual.type, formal) for actual, formal in zip(args, desc.arg_types)): if matching: assert matching.priority != desc.priority, 'Ambiguous:\n1) %s\n2) %s' % ( matching, desc) if desc.priority > matching.priority: matching = desc else: matching = desc if matching: target = self.primitive_op(matching, args, line) if result_type and not is_runtime_subtype(target.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() else: target = self.coerce(target, result_type, line) return target return None def binary_op(self, lreg: Value, rreg: Value, expr_op: str, line: int) -> Value: # Special case == and != when we can resolve the method call statically. value = None if expr_op in ('==', '!='): value = self.translate_eq_cmp(lreg, rreg, expr_op, line) if value is not None: return value # generate fast binary logic ops on short ints if (is_short_int_rprimitive(lreg.type) and is_short_int_rprimitive(rreg.type) and expr_op in int_logical_op_mapping.keys()): return self.binary_int_op(bool_rprimitive, lreg, rreg, int_logical_op_mapping[expr_op][0], line) call_c_ops_candidates = c_binary_ops.get(expr_op, []) target = self.matching_call_c(call_c_ops_candidates, [lreg, rreg], line) if target: return target ops = binary_ops.get(expr_op, []) target = self.matching_primitive_op(ops, [lreg, rreg], line) assert target, 'Unsupported binary operation: %s' % expr_op return target def check_tagged_short_int(self, val: Value, line: int) -> Value: """Check if a tagged integer is a short integer""" int_tag = self.add(LoadInt(1, line, rtype=c_pyssize_t_rprimitive)) bitwise_and = self.binary_int_op(c_pyssize_t_rprimitive, val, int_tag, BinaryIntOp.AND, line) zero = self.add(LoadInt(0, line, rtype=c_pyssize_t_rprimitive)) check = self.binary_int_op(bool_rprimitive, bitwise_and, zero, BinaryIntOp.EQ, line) return check def compare_tagged(self, lhs: Value, rhs: Value, op: str, line: int) -> Value: """Compare two tagged integers using given op""" op_type, c_func_desc = int_logical_op_mapping[op] result = self.alloc_temp(bool_rprimitive) short_int_block, int_block, out = BasicBlock(), BasicBlock(), BasicBlock() check = self.check_tagged_short_int(lhs, line) branch = Branch(check, short_int_block, int_block, Branch.BOOL_EXPR) branch.negated = False self.add(branch) self.activate_block(short_int_block) eq = self.binary_int_op(bool_rprimitive, lhs, rhs, op_type, line) self.add(Assign(result, eq, line)) self.goto(out) self.activate_block(int_block) call = self.call_c(c_func_desc, [lhs, rhs], line) self.add(Assign(result, call, line)) self.goto_and_activate(out) return result def unary_op(self, lreg: Value, expr_op: str, line: int) -> Value: call_c_ops_candidates = c_unary_ops.get(expr_op, []) target = self.matching_call_c(call_c_ops_candidates, [lreg], line) if target: return target ops = unary_ops.get(expr_op, []) target = self.matching_primitive_op(ops, [lreg], line) assert target, 'Unsupported unary operation: %s' % expr_op return target def make_dict(self, key_value_pairs: Sequence[DictEntry], line: int) -> Value: result = None # type: Union[Value, None] keys = [] # type: List[Value] values = [] # type: List[Value] for key, value in key_value_pairs: if key is not None: # key:value if result is None: keys.append(key) values.append(value) continue self.translate_special_method_call( result, '__setitem__', [key, value], result_type=None, line=line) else: # **value if result is None: result = self._create_dict(keys, values, line) self.call_c( dict_update_in_display_op, [result, value], line=line ) if result is None: result = self._create_dict(keys, values, line) return result def builtin_call(self, args: List[Value], fn_op: str, line: int) -> Value: call_c_ops_candidates = c_function_ops.get(fn_op, []) target = self.matching_call_c(call_c_ops_candidates, args, line) if target: return target ops = func_ops.get(fn_op, []) target = self.matching_primitive_op(ops, args, line) assert target, 'Unsupported builtin function: %s' % fn_op return target def shortcircuit_helper(self, op: str, expr_type: RType, left: Callable[[], Value], right: Callable[[], Value], line: int) -> Value: # Having actual Phi nodes would be really nice here! target = self.alloc_temp(expr_type) # left_body takes the value of the left side, right_body the right left_body, right_body, next = BasicBlock(), BasicBlock(), BasicBlock() # true_body is taken if the left is true, false_body if it is false. # For 'and' the value is the right side if the left is true, and for 'or' # it is the right side if the left is false. true_body, false_body = ( (right_body, left_body) if op == 'and' else (left_body, right_body)) left_value = left() self.add_bool_branch(left_value, true_body, false_body) self.activate_block(left_body) left_coerced = self.coerce(left_value, expr_type, line) self.add(Assign(target, left_coerced)) self.goto(next) self.activate_block(right_body) right_value = right() right_coerced = self.coerce(right_value, expr_type, line) self.add(Assign(target, right_coerced)) self.goto(next) self.activate_block(next) return target def add_bool_branch(self, value: Value, true: BasicBlock, false: BasicBlock) -> None: if is_runtime_subtype(value.type, int_rprimitive): zero = self.add(LoadInt(0)) value = self.binary_op(value, zero, '!=', value.line) elif is_same_type(value.type, list_rprimitive): length = self.primitive_op(list_len_op, [value], value.line) zero = self.add(LoadInt(0)) value = self.binary_op(length, zero, '!=', value.line) elif (isinstance(value.type, RInstance) and value.type.class_ir.is_ext_class and value.type.class_ir.has_method('__bool__')): # Directly call the __bool__ method on classes that have it. value = self.gen_method_call(value, '__bool__', [], bool_rprimitive, value.line) else: value_type = optional_value_type(value.type) if value_type is not None: is_none = self.binary_op(value, self.none_object(), 'is not', value.line) branch = Branch(is_none, true, false, Branch.BOOL_EXPR) self.add(branch) always_truthy = False if isinstance(value_type, RInstance): # check whether X.__bool__ is always just the default (object.__bool__) if (not value_type.class_ir.has_method('__bool__') and value_type.class_ir.is_method_final('__bool__')): always_truthy = True if not always_truthy: # Optional[X] where X may be falsey and requires a check branch.true = BasicBlock() self.activate_block(branch.true) # unbox_or_cast instead of coerce because we want the # type to change even if it is a subtype. remaining = self.unbox_or_cast(value, value_type, value.line) self.add_bool_branch(remaining, true, false) return elif not is_same_type(value.type, bool_rprimitive): value = self.primitive_op(bool_op, [value], value.line) self.add(Branch(value, true, false, Branch.BOOL_EXPR)) def call_c(self, desc: CFunctionDescription, args: List[Value], line: int, result_type: Optional[RType] = None) -> Value: # handle void function via singleton RVoid instance coerced = [] # coerce fixed number arguments for i in range(min(len(args), len(desc.arg_types))): formal_type = desc.arg_types[i] arg = args[i] arg = self.coerce(arg, formal_type, line) coerced.append(arg) # reorder args if necessary if desc.ordering is not None: assert desc.var_arg_type is None coerced = [coerced[i] for i in desc.ordering] # coerce any var_arg var_arg_idx = -1 if desc.var_arg_type is not None: var_arg_idx = len(desc.arg_types) for i in range(len(desc.arg_types), len(args)): arg = args[i] arg = self.coerce(arg, desc.var_arg_type, line) 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 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. result = self.none() else: result = self.coerce(target, result_type, line) return result def matching_call_c(self, candidates: List[CFunctionDescription], args: List[Value], line: int, result_type: Optional[RType] = None) -> Optional[Value]: # TODO: this function is very similar to matching_primitive_op # we should remove the old one or refactor both them into only as we move forward matching = None # type: Optional[CFunctionDescription] for desc in candidates: if len(desc.arg_types) != len(args): continue if all(is_subtype(actual.type, formal) for actual, formal in zip(args, desc.arg_types)): if matching: assert matching.priority != desc.priority, 'Ambiguous:\n1) %s\n2) %s' % ( matching, desc) if desc.priority > matching.priority: matching = desc else: matching = desc if matching: target = self.call_c(matching, args, line, result_type) return target return None def binary_int_op(self, type: RType, lhs: Value, rhs: Value, op: int, line: int) -> Value: return self.add(BinaryIntOp(type, lhs, rhs, op, line)) # Internal helpers def decompose_union_helper(self, obj: Value, rtype: RUnion, result_type: RType, process_item: Callable[[Value], Value], line: int) -> Value: """Generate isinstance() + specialized operations for union items. Say, for Union[A, B] generate ops resembling this (pseudocode): if isinstance(obj, A): result = <result of process_item(cast(A, obj)> else: result = <result of process_item(cast(B, obj)> Args: obj: value with a union type rtype: the union type result_type: result of the operation process_item: callback to generate op for a single union item (arg is coerced to union item type) line: line number """ # TODO: Optimize cases where a single operation can handle multiple union items # (say a method is implemented in a common base class) fast_items = [] rest_items = [] for item in rtype.items: if isinstance(item, RInstance): fast_items.append(item) else: # For everything but RInstance we fall back to C API rest_items.append(item) exit_block = BasicBlock() result = self.alloc_temp(result_type) for i, item in enumerate(fast_items): more_types = i < len(fast_items) - 1 or rest_items if more_types: # We are not at the final item so we need one more branch op = self.isinstance_native(obj, item.class_ir, line) true_block, false_block = BasicBlock(), BasicBlock() self.add_bool_branch(op, true_block, false_block) self.activate_block(true_block) coerced = self.coerce(obj, item, line) temp = process_item(coerced) temp2 = self.coerce(temp, result_type, line) self.add(Assign(result, temp2)) self.goto(exit_block) if more_types: self.activate_block(false_block) if rest_items: # For everything else we use generic operation. Use force=True to drop the # union type. coerced = self.coerce(obj, object_rprimitive, line, force=True) temp = process_item(coerced) temp2 = self.coerce(temp, result_type, line) self.add(Assign(result, temp2)) self.goto(exit_block) self.activate_block(exit_block) return result def op_arg_type(self, desc: OpDescription, n: int) -> RType: if n >= len(desc.arg_types): assert desc.is_var_arg return desc.arg_types[-1] return desc.arg_types[n] def translate_special_method_call(self, base_reg: Value, name: str, args: List[Value], result_type: Optional[RType], line: int) -> Optional[Value]: """Translate a method call which is handled nongenerically. These are special in the sense that we have code generated specifically for them. They tend to be method calls which have equivalents in C that are more direct than calling with the PyObject api. Return None if no translation found; otherwise return the target register. """ ops = method_ops.get(name, []) call_c_ops_candidates = c_method_call_ops.get(name, []) call_c_op = self.matching_call_c(call_c_ops_candidates, [base_reg] + args, line, result_type) if call_c_op is not None: return call_c_op return self.matching_primitive_op(ops, [base_reg] + args, line, result_type=result_type) def translate_eq_cmp(self, lreg: Value, rreg: Value, expr_op: str, line: int) -> Optional[Value]: """Add a equality comparison operation. Args: expr_op: either '==' or '!=' """ ltype = lreg.type rtype = rreg.type if not (isinstance(ltype, RInstance) and ltype == rtype): return None class_ir = ltype.class_ir # Check whether any subclasses of the operand redefines __eq__ # or it might be redefined in a Python parent class or by # dataclasses cmp_varies_at_runtime = ( not class_ir.is_method_final('__eq__') or not class_ir.is_method_final('__ne__') or class_ir.inherits_python or class_ir.is_augmented ) if cmp_varies_at_runtime: # We might need to call left.__eq__(right) or right.__eq__(left) # depending on which is the more specific type. return None if not class_ir.has_method('__eq__'): # There's no __eq__ defined, so just use object identity. identity_ref_op = 'is' if expr_op == '==' else 'is not' return self.binary_op(lreg, rreg, identity_ref_op, line) return self.gen_method_call( lreg, op_methods[expr_op], [rreg], ltype, line ) def _create_dict(self, keys: List[Value], values: List[Value], line: int) -> Value: """Create a dictionary(possibly empty) using keys and values""" # keys and values should have the same number of items size = len(keys) if size > 0: load_size_op = self.add(LoadInt(size, -1, c_pyssize_t_rprimitive)) # merge keys and values items = [i for t in list(zip(keys, values)) for i in t] return self.call_c(dict_build_op, [load_size_op] + items, line) else: return self.call_c(dict_new_op, [], line)
class TestFunctionEmitterVisitor(unittest.TestCase): def setUp(self) -> None: self.env = Environment() self.n = self.env.add_local(Var('n'), int_rprimitive) self.m = self.env.add_local(Var('m'), int_rprimitive) self.k = self.env.add_local(Var('k'), int_rprimitive) self.l = self.env.add_local(Var('l'), list_rprimitive) # noqa self.ll = self.env.add_local(Var('ll'), list_rprimitive) self.o = self.env.add_local(Var('o'), object_rprimitive) self.o2 = self.env.add_local(Var('o2'), object_rprimitive) self.d = self.env.add_local(Var('d'), dict_rprimitive) self.b = self.env.add_local(Var('b'), bool_rprimitive) self.t = self.env.add_local(Var('t'), RTuple([int_rprimitive, bool_rprimitive])) self.tt = self.env.add_local( Var('tt'), RTuple( [RTuple([int_rprimitive, bool_rprimitive]), bool_rprimitive])) ir = ClassIR('A', 'mod') ir.attributes = OrderedDict([('x', bool_rprimitive), ('y', int_rprimitive)]) compute_vtable(ir) ir.mro = [ir] self.r = self.env.add_local(Var('r'), RInstance(ir)) self.context = EmitterContext(NameGenerator([['mod']])) self.emitter = Emitter(self.context, self.env) self.declarations = Emitter(self.context, self.env) self.visitor = FunctionEmitterVisitor(self.emitter, self.declarations, 'prog.py', 'prog') def test_goto(self) -> None: self.assert_emit(Goto(BasicBlock(2)), "goto CPyL2;") def test_return(self) -> None: self.assert_emit(Return(self.m), "return cpy_r_m;") def test_load_int(self) -> None: self.assert_emit(LoadInt(5), "cpy_r_r0 = 10;") self.assert_emit(LoadInt(5, -1, c_int_rprimitive), "cpy_r_r00 = 5;") def test_tuple_get(self) -> None: self.assert_emit(TupleGet(self.t, 1, 0), 'cpy_r_r0 = cpy_r_t.f1;') def test_load_None(self) -> None: self.assert_emit(PrimitiveOp([], none_object_op, 0), "cpy_r_r0 = Py_None;") def test_load_True(self) -> None: self.assert_emit(PrimitiveOp([], true_op, 0), "cpy_r_r0 = 1;") def test_load_False(self) -> None: self.assert_emit(PrimitiveOp([], false_op, 0), "cpy_r_r0 = 0;") def test_assign_int(self) -> None: self.assert_emit(Assign(self.m, self.n), "cpy_r_m = cpy_r_n;") def test_int_add(self) -> None: self.assert_emit_binary_op( '+', self.n, self.m, self.k, "cpy_r_r0 = CPyTagged_Add(cpy_r_m, cpy_r_k);") def test_int_sub(self) -> None: self.assert_emit_binary_op( '-', self.n, self.m, self.k, "cpy_r_r0 = CPyTagged_Subtract(cpy_r_m, cpy_r_k);") def test_int_neg(self) -> None: self.assert_emit( CallC(int_neg_op.c_function_name, [self.m], int_neg_op.return_type, int_neg_op.steals, int_neg_op.error_kind, 55), "cpy_r_r0 = CPyTagged_Negate(cpy_r_m);") def test_list_len(self) -> None: self.assert_emit( PrimitiveOp([self.l], list_len_op, 55), """Py_ssize_t __tmp1; __tmp1 = PyList_GET_SIZE(cpy_r_l); cpy_r_r0 = CPyTagged_ShortFromSsize_t(__tmp1); """) def test_branch(self) -> None: self.assert_emit( Branch(self.b, BasicBlock(8), BasicBlock(9), Branch.BOOL_EXPR), """if (cpy_r_b) { goto CPyL8; } else goto CPyL9; """) b = Branch(self.b, BasicBlock(8), BasicBlock(9), Branch.BOOL_EXPR) b.negated = True self.assert_emit( b, """if (!cpy_r_b) { goto CPyL8; } else goto CPyL9; """) def test_call(self) -> None: decl = FuncDecl( 'myfn', None, 'mod', FuncSignature([RuntimeArg('m', int_rprimitive)], int_rprimitive)) self.assert_emit(Call(decl, [self.m], 55), "cpy_r_r0 = CPyDef_myfn(cpy_r_m);") def test_call_two_args(self) -> None: decl = FuncDecl( 'myfn', None, 'mod', FuncSignature([ RuntimeArg('m', int_rprimitive), RuntimeArg('n', int_rprimitive) ], int_rprimitive)) self.assert_emit(Call(decl, [self.m, self.k], 55), "cpy_r_r0 = CPyDef_myfn(cpy_r_m, cpy_r_k);") def test_inc_ref(self) -> None: self.assert_emit(IncRef(self.m), "CPyTagged_IncRef(cpy_r_m);") def test_dec_ref(self) -> None: self.assert_emit(DecRef(self.m), "CPyTagged_DecRef(cpy_r_m);") def test_dec_ref_tuple(self) -> None: self.assert_emit(DecRef(self.t), 'CPyTagged_DecRef(cpy_r_t.f0);') def test_dec_ref_tuple_nested(self) -> None: self.assert_emit(DecRef(self.tt), 'CPyTagged_DecRef(cpy_r_tt.f0.f0);') def test_list_get_item(self) -> None: self.assert_emit(PrimitiveOp([self.m, self.k], list_get_item_op, 55), """cpy_r_r0 = CPyList_GetItem(cpy_r_m, cpy_r_k);""") def test_list_set_item(self) -> None: self.assert_emit( PrimitiveOp([self.l, self.n, self.o], list_set_item_op, 55), """cpy_r_r0 = CPyList_SetItem(cpy_r_l, cpy_r_n, cpy_r_o);""") def test_box(self) -> None: self.assert_emit(Box(self.n), """cpy_r_r0 = CPyTagged_StealAsObject(cpy_r_n);""") def test_unbox(self) -> None: self.assert_emit( Unbox(self.m, int_rprimitive, 55), """if (likely(PyLong_Check(cpy_r_m))) cpy_r_r0 = CPyTagged_FromObject(cpy_r_m); else { CPy_TypeError("int", cpy_r_m); cpy_r_r0 = CPY_INT_TAG; } """) def test_new_list(self) -> None: self.assert_emit( PrimitiveOp([self.n, self.m], new_list_op, 55), """cpy_r_r0 = PyList_New(2); if (likely(cpy_r_r0 != NULL)) { PyList_SET_ITEM(cpy_r_r0, 0, cpy_r_n); PyList_SET_ITEM(cpy_r_r0, 1, cpy_r_m); } """) def test_list_append(self) -> None: self.assert_emit( PrimitiveOp([self.l, self.o], list_append_op, 1), """cpy_r_r0 = PyList_Append(cpy_r_l, cpy_r_o) >= 0;""") def test_get_attr(self) -> None: self.assert_emit( GetAttr(self.r, 'y', 1), """cpy_r_r0 = ((mod___AObject *)cpy_r_r)->_y; if (unlikely(((mod___AObject *)cpy_r_r)->_y == CPY_INT_TAG)) { PyErr_SetString(PyExc_AttributeError, "attribute 'y' of 'A' undefined"); } else { CPyTagged_IncRef(((mod___AObject *)cpy_r_r)->_y); } """) def test_set_attr(self) -> None: self.assert_emit( SetAttr(self.r, 'y', self.m, 1), """if (((mod___AObject *)cpy_r_r)->_y != CPY_INT_TAG) { CPyTagged_DecRef(((mod___AObject *)cpy_r_r)->_y); } ((mod___AObject *)cpy_r_r)->_y = cpy_r_m; cpy_r_r0 = 1; """) def test_dict_get_item(self) -> None: self.assert_emit(PrimitiveOp([self.d, self.o2], dict_get_item_op, 1), """cpy_r_r0 = CPyDict_GetItem(cpy_r_d, cpy_r_o2);""") def test_dict_set_item(self) -> None: self.assert_emit( PrimitiveOp([self.d, self.o, self.o2], dict_set_item_op, 1), """cpy_r_r0 = CPyDict_SetItem(cpy_r_d, cpy_r_o, cpy_r_o2) >= 0;""") def test_dict_update(self) -> None: self.assert_emit( PrimitiveOp([self.d, self.o], dict_update_op, 1), """cpy_r_r0 = CPyDict_Update(cpy_r_d, cpy_r_o) >= 0;""") def test_new_dict(self) -> None: self.assert_emit(PrimitiveOp([], new_dict_op, 1), """cpy_r_r0 = PyDict_New();""") def test_dict_contains(self) -> None: self.assert_emit_binary_op( 'in', self.b, self.o, self.d, """int __tmp1 = PyDict_Contains(cpy_r_d, cpy_r_o); if (__tmp1 < 0) cpy_r_r0 = 2; else cpy_r_r0 = __tmp1; """) def assert_emit(self, op: Op, expected: str) -> None: self.emitter.fragments = [] self.declarations.fragments = [] self.env.temp_index = 0 if isinstance(op, RegisterOp): self.env.add_op(op) op.accept(self.visitor) frags = self.declarations.fragments + self.emitter.fragments actual_lines = [line.strip(' ') for line in frags] assert all(line.endswith('\n') for line in actual_lines) actual_lines = [line.rstrip('\n') for line in actual_lines] expected_lines = expected.rstrip().split('\n') expected_lines = [line.strip(' ') for line in expected_lines] assert_string_arrays_equal(expected_lines, actual_lines, msg='Generated code unexpected') def assert_emit_binary_op(self, op: str, dest: Value, left: Value, right: Value, expected: str) -> None: ops = binary_ops[op] for desc in ops: if (is_subtype(left.type, desc.arg_types[0]) and is_subtype(right.type, desc.arg_types[1])): self.assert_emit(PrimitiveOp([left, right], desc, 55), expected) break else: assert False, 'Could not find matching op'
class TestFunctionEmitterVisitor(unittest.TestCase): def setUp(self) -> None: self.env = Environment() self.n = self.env.add_local(Var('n'), int_rprimitive) self.m = self.env.add_local(Var('m'), int_rprimitive) self.k = self.env.add_local(Var('k'), int_rprimitive) self.l = self.env.add_local(Var('l'), list_rprimitive) # noqa self.ll = self.env.add_local(Var('ll'), list_rprimitive) self.o = self.env.add_local(Var('o'), object_rprimitive) self.o2 = self.env.add_local(Var('o2'), object_rprimitive) self.d = self.env.add_local(Var('d'), dict_rprimitive) self.b = self.env.add_local(Var('b'), bool_rprimitive) self.s1 = self.env.add_local(Var('s1'), short_int_rprimitive) self.s2 = self.env.add_local(Var('s2'), short_int_rprimitive) self.i32 = self.env.add_local(Var('i32'), int32_rprimitive) self.i32_1 = self.env.add_local(Var('i32_1'), int32_rprimitive) self.i64 = self.env.add_local(Var('i64'), int64_rprimitive) self.i64_1 = self.env.add_local(Var('i64_1'), int64_rprimitive) self.ptr = self.env.add_local(Var('ptr'), pointer_rprimitive) self.t = self.env.add_local(Var('t'), RTuple([int_rprimitive, bool_rprimitive])) self.tt = self.env.add_local( Var('tt'), RTuple( [RTuple([int_rprimitive, bool_rprimitive]), bool_rprimitive])) ir = ClassIR('A', 'mod') ir.attributes = OrderedDict([('x', bool_rprimitive), ('y', int_rprimitive)]) compute_vtable(ir) ir.mro = [ir] self.r = self.env.add_local(Var('r'), RInstance(ir)) self.context = EmitterContext(NameGenerator([['mod']])) self.emitter = Emitter(self.context, self.env) self.declarations = Emitter(self.context, self.env) const_int_regs = {} # type: Dict[str, int] self.visitor = FunctionEmitterVisitor(self.emitter, self.declarations, 'prog.py', 'prog', const_int_regs) def test_goto(self) -> None: self.assert_emit(Goto(BasicBlock(2)), "goto CPyL2;") def test_return(self) -> None: self.assert_emit(Return(self.m), "return cpy_r_m;") def test_load_int(self) -> None: self.assert_emit(LoadInt(5), "cpy_r_i0 = 10;") self.assert_emit(LoadInt(5, -1, c_int_rprimitive), "cpy_r_i1 = 5;") def test_tuple_get(self) -> None: self.assert_emit(TupleGet(self.t, 1, 0), 'cpy_r_r0 = cpy_r_t.f1;') def test_load_None(self) -> None: self.assert_emit( LoadAddress(none_object_op.type, none_object_op.src, 0), "cpy_r_r0 = (PyObject *)&_Py_NoneStruct;") def test_assign_int(self) -> None: self.assert_emit(Assign(self.m, self.n), "cpy_r_m = cpy_r_n;") def test_int_add(self) -> None: self.assert_emit_binary_op( '+', self.n, self.m, self.k, "cpy_r_r0 = CPyTagged_Add(cpy_r_m, cpy_r_k);") def test_int_sub(self) -> None: self.assert_emit_binary_op( '-', self.n, self.m, self.k, "cpy_r_r0 = CPyTagged_Subtract(cpy_r_m, cpy_r_k);") def test_int_neg(self) -> None: self.assert_emit( CallC(int_neg_op.c_function_name, [self.m], int_neg_op.return_type, int_neg_op.steals, int_neg_op.is_borrowed, int_neg_op.is_borrowed, int_neg_op.error_kind, 55), "cpy_r_r0 = CPyTagged_Negate(cpy_r_m);") def test_branch(self) -> None: self.assert_emit( Branch(self.b, BasicBlock(8), BasicBlock(9), Branch.BOOL_EXPR), """if (cpy_r_b) { goto CPyL8; } else goto CPyL9; """) b = Branch(self.b, BasicBlock(8), BasicBlock(9), Branch.BOOL_EXPR) b.negated = True self.assert_emit( b, """if (!cpy_r_b) { goto CPyL8; } else goto CPyL9; """) def test_call(self) -> None: decl = FuncDecl( 'myfn', None, 'mod', FuncSignature([RuntimeArg('m', int_rprimitive)], int_rprimitive)) self.assert_emit(Call(decl, [self.m], 55), "cpy_r_r0 = CPyDef_myfn(cpy_r_m);") def test_call_two_args(self) -> None: decl = FuncDecl( 'myfn', None, 'mod', FuncSignature([ RuntimeArg('m', int_rprimitive), RuntimeArg('n', int_rprimitive) ], int_rprimitive)) self.assert_emit(Call(decl, [self.m, self.k], 55), "cpy_r_r0 = CPyDef_myfn(cpy_r_m, cpy_r_k);") def test_inc_ref(self) -> None: self.assert_emit(IncRef(self.m), "CPyTagged_IncRef(cpy_r_m);") def test_dec_ref(self) -> None: self.assert_emit(DecRef(self.m), "CPyTagged_DecRef(cpy_r_m);") def test_dec_ref_tuple(self) -> None: self.assert_emit(DecRef(self.t), 'CPyTagged_DecRef(cpy_r_t.f0);') def test_dec_ref_tuple_nested(self) -> None: self.assert_emit(DecRef(self.tt), 'CPyTagged_DecRef(cpy_r_tt.f0.f0);') def test_list_get_item(self) -> None: self.assert_emit( CallC(list_get_item_op.c_function_name, [self.m, self.k], list_get_item_op.return_type, list_get_item_op.steals, list_get_item_op.is_borrowed, list_get_item_op.error_kind, 55), """cpy_r_r0 = CPyList_GetItem(cpy_r_m, cpy_r_k);""") def test_list_set_item(self) -> None: self.assert_emit( CallC(list_set_item_op.c_function_name, [self.l, self.n, self.o], list_set_item_op.return_type, list_set_item_op.steals, list_set_item_op.is_borrowed, list_set_item_op.error_kind, 55), """cpy_r_r0 = CPyList_SetItem(cpy_r_l, cpy_r_n, cpy_r_o);""") def test_box(self) -> None: self.assert_emit(Box(self.n), """cpy_r_r0 = CPyTagged_StealAsObject(cpy_r_n);""") def test_unbox(self) -> None: self.assert_emit( Unbox(self.m, int_rprimitive, 55), """if (likely(PyLong_Check(cpy_r_m))) cpy_r_r0 = CPyTagged_FromObject(cpy_r_m); else { CPy_TypeError("int", cpy_r_m); cpy_r_r0 = CPY_INT_TAG; } """) def test_list_append(self) -> None: self.assert_emit( CallC(list_append_op.c_function_name, [self.l, self.o], list_append_op.return_type, list_append_op.steals, list_append_op.is_borrowed, list_append_op.error_kind, 1), """cpy_r_r0 = PyList_Append(cpy_r_l, cpy_r_o);""") def test_get_attr(self) -> None: self.assert_emit( GetAttr(self.r, 'y', 1), """cpy_r_r0 = ((mod___AObject *)cpy_r_r)->_y; if (unlikely(((mod___AObject *)cpy_r_r)->_y == CPY_INT_TAG)) { PyErr_SetString(PyExc_AttributeError, "attribute 'y' of 'A' undefined"); } else { CPyTagged_IncRef(((mod___AObject *)cpy_r_r)->_y); } """) def test_set_attr(self) -> None: self.assert_emit( SetAttr(self.r, 'y', self.m, 1), """if (((mod___AObject *)cpy_r_r)->_y != CPY_INT_TAG) { CPyTagged_DecRef(((mod___AObject *)cpy_r_r)->_y); } ((mod___AObject *)cpy_r_r)->_y = cpy_r_m; cpy_r_r0 = 1; """) def test_dict_get_item(self) -> None: self.assert_emit( CallC(dict_get_item_op.c_function_name, [self.d, self.o2], dict_get_item_op.return_type, dict_get_item_op.steals, dict_get_item_op.is_borrowed, dict_get_item_op.error_kind, 1), """cpy_r_r0 = CPyDict_GetItem(cpy_r_d, cpy_r_o2);""") def test_dict_set_item(self) -> None: self.assert_emit( CallC(dict_set_item_op.c_function_name, [self.d, self.o, self.o2], dict_set_item_op.return_type, dict_set_item_op.steals, dict_set_item_op.is_borrowed, dict_set_item_op.error_kind, 1), """cpy_r_r0 = CPyDict_SetItem(cpy_r_d, cpy_r_o, cpy_r_o2);""") def test_dict_update(self) -> None: self.assert_emit( CallC(dict_update_op.c_function_name, [self.d, self.o], dict_update_op.return_type, dict_update_op.steals, dict_update_op.is_borrowed, dict_update_op.error_kind, 1), """cpy_r_r0 = CPyDict_Update(cpy_r_d, cpy_r_o);""") def test_new_dict(self) -> None: self.assert_emit( CallC(dict_new_op.c_function_name, [], dict_new_op.return_type, dict_new_op.steals, dict_new_op.is_borrowed, dict_new_op.error_kind, 1), """cpy_r_r0 = PyDict_New();""") def test_dict_contains(self) -> None: self.assert_emit_binary_op( 'in', self.b, self.o, self.d, """cpy_r_r0 = PyDict_Contains(cpy_r_d, cpy_r_o);""") def test_binary_int_op(self) -> None: self.assert_emit( BinaryIntOp(short_int_rprimitive, self.s1, self.s2, BinaryIntOp.ADD, 1), """cpy_r_r0 = cpy_r_s1 + cpy_r_s2;""") self.assert_emit( BinaryIntOp(short_int_rprimitive, self.s1, self.s2, BinaryIntOp.SUB, 1), """cpy_r_r00 = cpy_r_s1 - cpy_r_s2;""") self.assert_emit( BinaryIntOp(short_int_rprimitive, self.s1, self.s2, BinaryIntOp.MUL, 1), """cpy_r_r01 = cpy_r_s1 * cpy_r_s2;""") self.assert_emit( BinaryIntOp(short_int_rprimitive, self.s1, self.s2, BinaryIntOp.DIV, 1), """cpy_r_r02 = cpy_r_s1 / cpy_r_s2;""") self.assert_emit( BinaryIntOp(short_int_rprimitive, self.s1, self.s2, BinaryIntOp.MOD, 1), """cpy_r_r03 = cpy_r_s1 % cpy_r_s2;""") self.assert_emit( BinaryIntOp(short_int_rprimitive, self.s1, self.s2, BinaryIntOp.AND, 1), """cpy_r_r04 = cpy_r_s1 & cpy_r_s2;""") self.assert_emit( BinaryIntOp(short_int_rprimitive, self.s1, self.s2, BinaryIntOp.OR, 1), """cpy_r_r05 = cpy_r_s1 | cpy_r_s2;""") self.assert_emit( BinaryIntOp(short_int_rprimitive, self.s1, self.s2, BinaryIntOp.XOR, 1), """cpy_r_r06 = cpy_r_s1 ^ cpy_r_s2;""") self.assert_emit( BinaryIntOp(short_int_rprimitive, self.s1, self.s2, BinaryIntOp.LEFT_SHIFT, 1), """cpy_r_r07 = cpy_r_s1 << cpy_r_s2;""") self.assert_emit( BinaryIntOp(short_int_rprimitive, self.s1, self.s2, BinaryIntOp.RIGHT_SHIFT, 1), """cpy_r_r08 = cpy_r_s1 >> cpy_r_s2;""") def test_comparison_op(self) -> None: # signed self.assert_emit( ComparisonOp(self.s1, self.s2, ComparisonOp.SLT, 1), """cpy_r_r0 = (Py_ssize_t)cpy_r_s1 < (Py_ssize_t)cpy_r_s2;""") self.assert_emit( ComparisonOp(self.i32, self.i32_1, ComparisonOp.SLT, 1), """cpy_r_r00 = cpy_r_i32 < cpy_r_i32_1;""") self.assert_emit( ComparisonOp(self.i64, self.i64_1, ComparisonOp.SLT, 1), """cpy_r_r01 = cpy_r_i64 < cpy_r_i64_1;""") # unsigned self.assert_emit(ComparisonOp(self.s1, self.s2, ComparisonOp.ULT, 1), """cpy_r_r02 = cpy_r_s1 < cpy_r_s2;""") self.assert_emit( ComparisonOp(self.i32, self.i32_1, ComparisonOp.ULT, 1), """cpy_r_r03 = (uint32_t)cpy_r_i32 < (uint32_t)cpy_r_i32_1;""") self.assert_emit( ComparisonOp(self.i64, self.i64_1, ComparisonOp.ULT, 1), """cpy_r_r04 = (uint64_t)cpy_r_i64 < (uint64_t)cpy_r_i64_1;""") # object type self.assert_emit(ComparisonOp(self.o, self.o2, ComparisonOp.EQ, 1), """cpy_r_r05 = cpy_r_o == cpy_r_o2;""") self.assert_emit(ComparisonOp(self.o, self.o2, ComparisonOp.NEQ, 1), """cpy_r_r06 = cpy_r_o != cpy_r_o2;""") def test_load_mem(self) -> None: self.assert_emit(LoadMem(bool_rprimitive, self.ptr, None), """cpy_r_r0 = *(char *)cpy_r_ptr;""") self.assert_emit(LoadMem(bool_rprimitive, self.ptr, self.s1), """cpy_r_r00 = *(char *)cpy_r_ptr;""") def test_set_mem(self) -> None: self.assert_emit(SetMem(bool_rprimitive, self.ptr, self.b, None), """*(char *)cpy_r_ptr = cpy_r_b;""") def test_get_element_ptr(self) -> None: r = RStruct("Foo", ["b", "i32", "i64"], [bool_rprimitive, int32_rprimitive, int64_rprimitive]) self.assert_emit(GetElementPtr(self.o, r, "b"), """cpy_r_r0 = (CPyPtr)&((Foo *)cpy_r_o)->b;""") self.assert_emit(GetElementPtr(self.o, r, "i32"), """cpy_r_r00 = (CPyPtr)&((Foo *)cpy_r_o)->i32;""") self.assert_emit(GetElementPtr(self.o, r, "i64"), """cpy_r_r01 = (CPyPtr)&((Foo *)cpy_r_o)->i64;""") def test_load_address(self) -> None: self.assert_emit(LoadAddress(object_rprimitive, "PyDict_Type"), """cpy_r_r0 = (PyObject *)&PyDict_Type;""") def assert_emit(self, op: Op, expected: str) -> None: self.emitter.fragments = [] self.declarations.fragments = [] self.env.temp_index = 0 if isinstance(op, RegisterOp): self.env.add_op(op) op.accept(self.visitor) frags = self.declarations.fragments + self.emitter.fragments actual_lines = [line.strip(' ') for line in frags] assert all(line.endswith('\n') for line in actual_lines) actual_lines = [line.rstrip('\n') for line in actual_lines] expected_lines = expected.rstrip().split('\n') expected_lines = [line.strip(' ') for line in expected_lines] assert_string_arrays_equal(expected_lines, actual_lines, msg='Generated code unexpected') def assert_emit_binary_op(self, op: str, dest: Value, left: Value, right: Value, expected: str) -> None: # TODO: merge this if op in c_binary_ops: c_ops = c_binary_ops[op] for c_desc in c_ops: if (is_subtype(left.type, c_desc.arg_types[0]) and is_subtype(right.type, c_desc.arg_types[1])): args = [left, right] if c_desc.ordering is not None: args = [args[i] for i in c_desc.ordering] self.assert_emit( CallC(c_desc.c_function_name, args, c_desc.return_type, c_desc.steals, c_desc.is_borrowed, c_desc.error_kind, 55), expected) return else: assert False, 'Could not find matching op'
def split_blocks_at_errors(blocks: List[BasicBlock], default_error_handler: BasicBlock, func_name: Optional[str], env: Environment) -> List[BasicBlock]: new_blocks = [] # type: List[BasicBlock] # First split blocks on ops that may raise. for block in blocks: ops = block.ops block.ops = [] cur_block = block new_blocks.append(cur_block) # If the block has an error handler specified, use it. Otherwise # fall back to the default. error_label = block.error_handler or default_error_handler block.error_handler = None for op in ops: target = op cur_block.ops.append(op) if isinstance(op, RegisterOp) and op.error_kind != ERR_NEVER: # Split new_block = BasicBlock() new_blocks.append(new_block) if op.error_kind == ERR_MAGIC: # Op returns an error value on error that depends on result RType. variant = Branch.IS_ERROR negated = False elif op.error_kind == ERR_FALSE: # Op returns a C false value on error. variant = Branch.BOOL negated = True elif op.error_kind == ERR_ALWAYS: variant = Branch.BOOL negated = True # this is a hack to represent the always fail # semantics, using a temporary bool with value false tmp = LoadInt(0, rtype=bool_rprimitive) cur_block.ops.append(tmp) env.add_op(tmp) target = tmp else: assert False, 'unknown error kind %d' % op.error_kind # Void ops can't generate errors since error is always # indicated by a special value stored in a register. if op.error_kind != ERR_ALWAYS: assert not op.is_void, "void op generating errors?" branch = Branch(target, true_label=error_label, false_label=new_block, op=variant, line=op.line) branch.negated = negated if op.line != NO_TRACEBACK_LINE_NO and func_name is not None: branch.traceback_entry = (func_name, op.line) cur_block.ops.append(branch) cur_block = new_block return new_blocks