Jan 13, 2024 · Jan 13, 2024 · Jan 13, 2024 · Jan 13, 2024 · Jan 14, 2024 · Jan 14, 2024
diff --git a/Python/abstract_interp_cases.c.h b/Python/abstract_interp_cases.c.h
diff --git a/Python/optimizer_analysis.c b/Python/optimizer_analysis.c
 }

 static inline PyObject *
 get_const(_Py_UOpsSymType *expr)
 get_const_borrow(_Py_UOpsSymType *expr)
 {
    return expr->const_val;
 }

 static inline PyObject *
 get_const(_Py_UOpsSymType *expr)
 {
    return Py_NewRef(expr->const_val);
 }


 static int
 clear_locals_type_info(_Py_UOpsAbstractInterpContext *ctx) {
    switch(opcode) {
        case _SET_IP:
        case _CHECK_VALIDITY:
        case _LOAD_CONST_INLINE:
        case _LOAD_CONST_INLINE_BORROW:
        case _LOAD_CONST_INLINE_WITH_NULL:
        case _LOAD_CONST_INLINE_BORROW_WITH_NULL:
        case _LOAD_CONST:
        case _LOAD_FAST:
        case _NOP:
            return true;
        default:
            returnfalse;
            return_PyUop_Flags[opcode] & HAS_PURE_FLAG;
    }
 }

                ctx, oparg);
            assert(is_const(PEEK(1)));
            // Peephole: inline constants.
            PyObject *val =get_const(PEEK(1));
            PyObject *val =get_const_borrow(PEEK(1));
            new_inst.opcode = _Py_IsImmortal(val) ? _LOAD_CONST_INLINE_BORROW : _LOAD_CONST_INLINE;
            if (new_inst.opcode == _LOAD_CONST_INLINE) {
                Py_INCREF(val);
diff --git a/Tools/cases_generator/tier2_abstract_generator.py b/Tools/cases_generator/tier2_abstract_generator.py
 }


 MANGLED_NULL = "__null_"

 def declare_variables(
    uop: Uop,
    out: CWriter,
                    out.emit(f"{type}{var.name} = NULL;\n")
                else:
                    out.emit(f"{type}{var.name};\n")
                if var.name == MANGLED_NULL and not var.peek:
                    out.emit(f"{var.name} = sym_init_push_null(ctx);\n")
                    out.emit(f"if ({var.name} == NULL) {{ goto error; }}\n")
    for var in uop.stack.outputs:
        if skip_peeks and var.peek:
            continue
                out.emit(f"{type}{var.name} = NULL;\n")
            else:
                out.emit(f"{type}{var.name};\n")
            if var.name == MANGLED_NULL and not var.peek:
                out.emit(f"{var.name} = sym_init_push_null(ctx);\n")
                out.emit(f"if ({var.name} == NULL) {{ goto error; }}\n")


 def tier2_replace_deopt(
    out.emit(") goto error;\n")


 def tier2_replace_decref_specialized(
    out: CWriter,
    tkn: Token,
    tkn_iter: Iterator[Token],
    uop: Uop,
    unused: Stack,
    inst: Instruction | None,
 ) -> None:
    parens = 1
    next(tkn_iter)  # LPAREN
    for tkn in tkn_iter:
        if tkn.kind == "LPAREN":
            parens += 1
        if tkn.kind == "RPAREN":
            parens -= 1
            if parens == 0:
                break
    next(tkn_iter)  # SEMICOLON


 TIER2_REPLACEMENT_FUNCTIONS = REPLACEMENT_FUNCTIONS.copy()
 TIER2_REPLACEMENT_FUNCTIONS["ERROR_IF"] = tier2_replace_error
 TIER2_REPLACEMENT_FUNCTIONS["DEOPT_IF"] = tier2_replace_deopt
 TIER2_REPLACEMENT_FUNCTIONS["_Py_DECREF_SPECIALIZED"] = tier2_replace_decref_specialized


 def _write_body_abstract_interp_impure_uop(
    mangled_uop: Uop, uop: Uop, out: CWriter, stack: Stack
            continue

        if var.size == "1":
            out.emit(f"{var.name} = sym_init_unknown(ctx);\n")
            out.emit(f"if({var.name} == NULL) goto error;\n")
            if var.name in ("null", "__null_"):
                out.emit(f"sym_set_type({var.name}, NULL_TYPE, 0);\n")
            elif var.type_prop:
                out.emit(f"sym_set_type({var.name}, {var.type_prop[0]}, 0);\n")
            if var.name != MANGLED_NULL:
                out.emit(f"{var.name} = sym_init_unknown(ctx);\n")
                out.emit(f"if({var.name} == NULL) goto error;\n")
                if var.type_prop:
                    out.emit(f"sym_set_type({var.name}, {var.type_prop[0]}, 0);\n")
        else:
            # See UNPACK_SEQUENCE for when we need this.
            out.emit(
    )


 def declare_caches(uop: Uop, out: CWriter):
    for cache in uop.caches:
        if cache.name not in UNUSED:
            if cache.size == 4:
                type = cast = "PyObject *"
            else:
                type = f"uint{cache.size*16}_t "
                cast = f"uint{cache.size*16}_t"
            out.emit(f"{type}{cache.name} = ({cast})CURRENT_OPERAND();\n")


 def _write_body_abstract_interp_pure_uop(
    mangled_uop: Uop, uop: Uop, out: CWriter, stack: Stack
 ) -> None:
    arr_var_name, arr_var_size, subexpressions = get_subexpressions(
        mangled_uop.stack.inputs
    )

    # uop ismandatory - we cannot const evaluate it
    # uop isnon-trivial - we cannot const evaluate it
    if uop.name in NO_CONST_OR_TYPE_EVALUATE:
        for in_ in mangled_uop.stack.inputs:
            out.emit(f"(void){in_.name};\n")
        return

    assert (
        len(uop.stack.outputs) == 1
    ), f"Currently we only support 1 stack output for pure ops: {uop}"

    # Constant prop only handles one output, and no variadic inputs.
    # Constant prop handled no variadic inputs.
    # Perhaps in the future we can support these.
    if all(input.size == "1" for input in uop.stack.inputs):
        # We can try a constant evaluation
            ]
        )

        if predicates:
            declare_caches(uop, out)

        out.emit(f"if ({predicates or 0}) {{\n")
        declare_variables(uop, out, default_type="PyObject *")
        for var, mangled_var in zip(uop.stack.inputs, mangled_uop.stack.inputs):
    if uop.name in NO_CONST_OR_TYPE_EVALUATE:
        return

    for cache in uop.caches:
        if cache.name not in UNUSED:
            if cache.size == 4:
                type = cast = "PyObject *"
            else:
                type = f"uint{cache.size*16}_t "
                cast = f"uint{cache.size*16}_t"
            out.emit(f"{type}{cache.name} = ({cast})CURRENT_OPERAND();\n")

    out.emit("// Constant evaluation\n")
    predicates_str = " && ".join(
        [
        ]
    )
    if predicates_str:
        declare_caches(uop, out)
        out.emit(f"if ({predicates_str}) {{\n")
        declare_variables(uop, out, default_type="PyObject *")
        for var, mangled_var in zip(uop.stack.inputs, mangled_uop.stack.inputs):
Original file line number	Diff line number	Diff line change
Expand Up		@@ -495,11 +495,17 @@ is_const(_Py_UOpsSymType *expr)
		}

		static inline PyObject *
		get_const(_Py_UOpsSymType *expr)
		get_const_borrow(_Py_UOpsSymType *expr)
		{
		return expr->const_val;
		}

		static inline PyObject *
		get_const(_Py_UOpsSymType *expr)
		{
		return Py_NewRef(expr->const_val);
		}


		static int
		clear_locals_type_info(_Py_UOpsAbstractInterpContext *ctx) {
Expand DownExpand Up		@@ -544,16 +550,9 @@ op_is_zappable(int opcode)
		switch(opcode) {
		case _SET_IP:
		case _CHECK_VALIDITY:
		case _LOAD_CONST_INLINE:
		case _LOAD_CONST_INLINE_BORROW:
		case _LOAD_CONST_INLINE_WITH_NULL:
		case _LOAD_CONST_INLINE_BORROW_WITH_NULL:
		case _LOAD_CONST:
		case _LOAD_FAST:
		case _NOP:
		return true;
		default:
		returnfalse;
		return_PyUop_Flags[opcode] & HAS_PURE_FLAG;
		}
		}

Expand DownExpand Up		@@ -731,7 +730,7 @@ uop_abstract_interpret_single_inst(
		ctx, oparg);
		assert(is_const(PEEK(1)));
		// Peephole: inline constants.
		PyObject *val =get_const(PEEK(1));
		PyObject *val =get_const_borrow(PEEK(1));
		new_inst.opcode = _Py_IsImmortal(val) ? _LOAD_CONST_INLINE_BORROW : _LOAD_CONST_INLINE;
		if (new_inst.opcode == _LOAD_CONST_INLINE) {
		Py_INCREF(val);
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -51,6 +51,8 @@
		}


		MANGLED_NULL = "__null_"

		def declare_variables(
		uop: Uop,
		out: CWriter,
Expand All		@@ -75,6 +77,9 @@ def declare_variables(
		out.emit(f"{type}{var.name} = NULL;\n")
		else:
		out.emit(f"{type}{var.name};\n")
		if var.name == MANGLED_NULL and not var.peek:
		out.emit(f"{var.name} = sym_init_push_null(ctx);\n")
		out.emit(f"if ({var.name} == NULL) {{ goto error; }}\n")
		for var in uop.stack.outputs:
		if skip_peeks and var.peek:
		continue
Expand All		@@ -89,6 +94,9 @@ def declare_variables(
		out.emit(f"{type}{var.name} = NULL;\n")
		else:
		out.emit(f"{type}{var.name};\n")
		if var.name == MANGLED_NULL and not var.peek:
		out.emit(f"{var.name} = sym_init_push_null(ctx);\n")
		out.emit(f"if ({var.name} == NULL) {{ goto error; }}\n")


		def tier2_replace_deopt(
Expand All		@@ -106,31 +114,9 @@ def tier2_replace_deopt(
		out.emit(") goto error;\n")


		def tier2_replace_decref_specialized(
		out: CWriter,
		tkn: Token,
		tkn_iter: Iterator[Token],
		uop: Uop,
		unused: Stack,
		inst: Instruction \| None,
		) -> None:
		parens = 1
		next(tkn_iter) # LPAREN
		for tkn in tkn_iter:
		if tkn.kind == "LPAREN":
		parens += 1
		if tkn.kind == "RPAREN":
		parens -= 1
		if parens == 0:
		break
		next(tkn_iter) # SEMICOLON


		TIER2_REPLACEMENT_FUNCTIONS = REPLACEMENT_FUNCTIONS.copy()
		TIER2_REPLACEMENT_FUNCTIONS["ERROR_IF"] = tier2_replace_error
		TIER2_REPLACEMENT_FUNCTIONS["DEOPT_IF"] = tier2_replace_deopt
		TIER2_REPLACEMENT_FUNCTIONS["_Py_DECREF_SPECIALIZED"] = tier2_replace_decref_specialized


		def _write_body_abstract_interp_impure_uop(
		mangled_uop: Uop, uop: Uop, out: CWriter, stack: Stack
Expand All		@@ -142,12 +128,11 @@ def _write_body_abstract_interp_impure_uop(
		continue

		if var.size == "1":
		out.emit(f"{var.name} = sym_init_unknown(ctx);\n")
		out.emit(f"if({var.name} == NULL) goto error;\n")
		if var.name in ("null", "__null_"):
		out.emit(f"sym_set_type({var.name}, NULL_TYPE, 0);\n")
		elif var.type_prop:
		out.emit(f"sym_set_type({var.name}, {var.type_prop[0]}, 0);\n")
		if var.name != MANGLED_NULL:
		out.emit(f"{var.name} = sym_init_unknown(ctx);\n")
		out.emit(f"if({var.name} == NULL) goto error;\n")
		if var.type_prop:
		out.emit(f"sym_set_type({var.name}, {var.type_prop[0]}, 0);\n")
Comment on lines +131 to +135 Copy link Member gvanrossumFeb 4, 2024 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. This is an example of something that I think can be streamlined further. Instead of calling`sym_init_unknown(ctx)` followed by`sym_set_type(...)` there ought to be a single function you can call to create a symbol with a given type. Basically a bunch of convenience constructors.
		else:
		# See UNPACK_SEQUENCE for when we need this.
		out.emit(
Expand DownExpand Up		@@ -202,24 +187,31 @@ def new_sym(
		)


		def declare_caches(uop: Uop, out: CWriter):
		for cache in uop.caches:
		if cache.name not in UNUSED:
		if cache.size == 4:
		type = cast = "PyObject *"
		else:
		type = f"uint{cache.size*16}_t "
		cast = f"uint{cache.size*16}_t"
		out.emit(f"{type}{cache.name} = ({cast})CURRENT_OPERAND();\n")


		def _write_body_abstract_interp_pure_uop(
		mangled_uop: Uop, uop: Uop, out: CWriter, stack: Stack
		) -> None:
		arr_var_name, arr_var_size, subexpressions = get_subexpressions(
		mangled_uop.stack.inputs
		)

		# uop ismandatory - we cannot const evaluate it
		# uop isnon-trivial - we cannot const evaluate it
		if uop.name in NO_CONST_OR_TYPE_EVALUATE:
		for in_ in mangled_uop.stack.inputs:
		out.emit(f"(void){in_.name};\n")
		return

		assert (
		len(uop.stack.outputs) == 1
		), f"Currently we only support 1 stack output for pure ops: {uop}"

		# Constant prop only handles one output, and no variadic inputs.
		# Constant prop handled no variadic inputs.
		# Perhaps in the future we can support these.
		if all(input.size == "1" for input in uop.stack.inputs):
		# We can try a constant evaluation
Expand All		@@ -232,6 +224,9 @@ def _write_body_abstract_interp_pure_uop(
		]
		)

		if predicates:
		declare_caches(uop, out)

		out.emit(f"if ({predicates or 0}) {{\n")
		declare_variables(uop, out, default_type="PyObject *")
		for var, mangled_var in zip(uop.stack.inputs, mangled_uop.stack.inputs):
Expand DownExpand Up		@@ -273,15 +268,6 @@ def _write_body_abstract_interp_guard_uop(
		if uop.name in NO_CONST_OR_TYPE_EVALUATE:
		return

		for cache in uop.caches:
		if cache.name not in UNUSED:
		if cache.size == 4:
		type = cast = "PyObject *"
		else:
		type = f"uint{cache.size*16}_t "
		cast = f"uint{cache.size*16}_t"
		out.emit(f"{type}{cache.name} = ({cast})CURRENT_OPERAND();\n")

		out.emit("// Constant evaluation\n")
		predicates_str = " && ".join(
		[
Expand All		@@ -291,6 +277,7 @@ def _write_body_abstract_interp_guard_uop(
		]
		)
		if predicates_str:
		declare_caches(uop, out)
		out.emit(f"if ({predicates_str}) {{\n")
		declare_variables(uop, out, default_type="PyObject *")
		for var, mangled_var in zip(uop.stack.inputs, mangled_uop.stack.inputs):
Expand Down