Merge branch 'main' into gh-149819-fix-pth-subprocess

Author: warsaw

Include/internal/pycore_magic_number.h

@@ -298,6 +298,7 @@ Known values:
     Python 3.15a8 3665 (Add FOR_ITER_VIRTUAL and GET_ITER specializations)
     Python 3.15b1 3666 (Add SEND_VIRTUAL and SEND_ASYNC_GEN specializations)
     Python 3.16a0 3700 (Initial version)
+    Python 3.16a0 3701 (Add CONSTANT_EMPTY_TUPLE to LOAD_COMMON_CONSTANT)
 
 
     Python 3.17 will start with 3750
@@ -311,7 +312,7 @@ PC/launcher.c must also be updated.
 
 */
 
-#define PYC_MAGIC_NUMBER 3700
+#define PYC_MAGIC_NUMBER 3701
 /* This is equivalent to converting PYC_MAGIC_NUMBER to 2 bytes
    (little-endian) and then appending b'\r\n'. */
 #define PYC_MAGIC_NUMBER_TOKEN \

Include/internal/pycore_opcode_utils.h

@@ -81,7 +81,8 @@ extern "C" {
 #define CONSTANT_FALSE 10
 #define CONSTANT_MINUS_ONE 11
 #define CONSTANT_BUILTIN_FROZENSET 12
-#define NUM_COMMON_CONSTANTS 13
+#define CONSTANT_EMPTY_TUPLE 13
+#define NUM_COMMON_CONSTANTS 14
 
 /* Values used in the oparg for RESUME */
 #define RESUME_AT_FUNC_START 0

Include/internal/pycore_optimizer.h

@@ -31,9 +31,8 @@ extern "C" {
  * 4. A push followed by a matching return is net-zero on frame-specific
  *    fitness, excluding per-slot costs.
  */
-#define MAX_TARGET_LENGTH          (UOP_MAX_TRACE_LENGTH / 2)
 #define OPTIMIZER_EFFECTIVENESS    2
-#define FITNESS_INITIAL            (MAX_TARGET_LENGTH * OPTIMIZER_EFFECTIVENESS)
+#define MAX_TARGET_LENGTH          (FITNESS_INITIAL / OPTIMIZER_EFFECTIVENESS)
 
 /* Exit quality thresholds: trace stops when fitness < exit_quality.
  * Higher = trace is more willing to stop here. */

Include/internal/pycore_uop.h

@@ -36,14 +36,18 @@ typedef struct _PyUOpInstruction{
 #endif
 } _PyUOpInstruction;
 
-// This is the length of the trace we translate initially.
+// Fitness is the target length of the trace we translate initially. The uop
+// buffer has a small amount of extra space for entry/loop-closing overhead.
 #if defined(Py_DEBUG) && defined(_Py_JIT)
     // With asserts, the stencils are a lot larger
-#define UOP_MAX_TRACE_LENGTH 1000
+#define FITNESS_INITIAL 1000
 #else
-#define UOP_MAX_TRACE_LENGTH 2500
+#define FITNESS_INITIAL 2500
 #endif
 
+#define UOP_TRACE_BUFFER_OVERHEAD 10
+#define UOP_MAX_TRACE_LENGTH (FITNESS_INITIAL + UOP_TRACE_BUFFER_OVERHEAD)
+
 /* Bloom filter with m = 256
  * https://en.wikipedia.org/wiki/Bloom_filter */
 #ifdef HAVE_GCC_UINT128_T

Lib/dis.py

@@ -698,8 +698,8 @@ def _get_const_value(op, arg, co_consts):
     if op == LOAD_SMALL_INT:
         return arg
     if op == LOAD_COMMON_CONSTANT:
-        # Opargs 0-6 are callables; 7-11 are literal values.
-        if 7 <= arg <= 11:
+        # Opargs 0-6 and 12 are callables; 7-11 and 13 are literal values.
+        if 7 <= arg <= 11 or arg == 13:
             return _common_constants[arg]
         return UNKNOWN
     argval = UNKNOWN

Lib/opcode.py

@@ -44,7 +44,7 @@
                      builtins.set,
                      # Append-only — must match CONSTANT_* in
                      # Include/internal/pycore_opcode_utils.h.
-                     None, "", True, False, -1, builtins.frozenset]
+                     None, "", True, False, -1, builtins.frozenset, ()]
 _nb_ops = _opcode.get_nb_ops()
 
 hascompare = [opmap["COMPARE_OP"]]

Lib/tarfile.py

@@ -498,7 +498,7 @@ def _init_read_gz(self):
 
         if flag & 4:
             xlen = ord(self.__read(1)) + 256 * ord(self.__read(1))
-            self.read(xlen)
+            self.__read(xlen)
         if flag & 8:
             while True:
                 s = self.__read(1)

Lib/test/test_capi/test_opt.py

@@ -5924,6 +5924,44 @@ def __next__(self):
         """), PYTHON_JIT="1", PYTHON_JIT_STRESS="1")
         self.assertEqual(result[0].rc, 0, result)
 
+    def test_149335_trace_buffer_guard(self):
+        # https://github.com/python/cpython/issues/149335
+
+        result = script_helper.run_python_until_end('-c', textwrap.dedent("""
+        import sys
+
+        def f1():
+            for i_3178 in 0, 2, 10:
+                mv162 = 162
+
+            mv3 = mv1 = mv_165 = mv16 = \
+            mv167 = mv168 = \
+            mv169 = \
+                mv_1403_170 = \
+                169
+
+            mv_1403_170
+
+            mv_172 = mv_3 = mv_4 = mv175 = mv176 = mv17 = mv178 = mv179 = mv0 = mv1 = mv182 = (
+            mv3
+            ) = mv4 = mv185 = mv186 = mv187 = mv18 = mv189 = mv0 = mv1 = mv192 = mv3 = mv4 = (
+            mv195
+            ) = mv196 = mv197 = mv_198 = mv19 = mv0 = mv1 = mv2 = mv3 = mv4 = mv05 = mv06 = (
+            mv07
+            ) = mv08 = mv09 = mv0 = mv1 = mv2 = mv3 = mv4 = mv15 = mv16 = mv17 = mv18 = mv19 = (
+            mv0
+            ) = mv1 = mv_2 = mv3 = mv4 = mv_25 = mv_26 = mv_27 = mv_28 = mv_29 = mv0 = mv1 = (
+            mv2
+            ) = mv_1403 = mv4 = mv35 = mv36 = mv37 = mv38 = mv39 = mv0 = -sys.maxsize / 3
+
+            mv1 = mv_12 = mv3 = mv_14 = mv45 = sys.float_info.epsilon
+            mv46 = sys.float_info.epsilon
+
+        for i in range(15000):
+            f1()
+        """), PYTHON_JIT="1")
+        self.assertEqual(result[0].rc, 0, result)
+
     def test_144068_daemon_thread_jit_cleanup(self):
         result = script_helper.run_python_until_end('-c', textwrap.dedent("""
         import threading

Lib/test/test_crossinterp.py

@@ -157,6 +157,10 @@ def ignore_byteswarning():
     {},
     {1: 7, 2: 8, 3: 9},
     {1: [1], 2: (2,), 3: {3: 4}},
+    # frozendict
+    frozendict(),
+    frozendict({1: 7, 2: 8, 3: 9}),
+    frozendict({1: [1], 2: (2,), 3: {3: 4}, 4: frozendict({5: 6})}),
     # set
     set(),
     {1, 2, 3},

Lib/test/test_generated_cases.py

@@ -2187,6 +2187,75 @@ def test_family_member_needs_transform_only_when_shape_changes(self):
             "[OP_TYPED_SPECIALIZED] = {1, 0, {0}}",
         )
 
+    def test_record_transform_generated_from_recording_uop(self):
+        input = """
+        tier2 op(_RECORD_TOS, (tos -- tos)) {
+            RECORD_VALUE(PyStackRef_AsPyObjectBorrow(tos));
+        }
+        tier2 op(_RECORD_TOS_TYPE, (tos -- tos)) {
+            RECORD_VALUE(Py_TYPE(PyStackRef_AsPyObjectBorrow(tos)));
+        }
+        op(_DO_STUFF, (tos -- res)) {
+            res = tos;
+        }
+        macro(OP) = _RECORD_TOS + _DO_STUFF;
+        macro(OP_SPECIALIZED) = _RECORD_TOS_TYPE + _DO_STUFF;
+        family(OP, INLINE_CACHE_ENTRIES_OP) = { OP_SPECIALIZED };
+        """
+        output = self.generate_tables(input)
+        self.assertIn("_PyOpcode_RecordTransform_TOS_TYPE", output)
+        self.assertIn("tos = PyStackRef_FromPyObjectBorrow(recorded_value);", output)
+        self.assertIn(
+            "transformed_value = (PyObject *)Py_TYPE(PyStackRef_AsPyObjectBorrow(tos));",
+            output,
+        )
+        self.assertIn("return _PyOpcode_RecordTransform_TOS_TYPE(value);", output)
+        self.assertNotIn("record_trace_transform_to_type", output)
+
+    def test_record_transform_generated_when_only_specialization_records(self):
+        input = """
+        tier2 op(_RECORD_TOS_TYPE, (tos -- tos)) {
+            RECORD_VALUE(Py_TYPE(PyStackRef_AsPyObjectBorrow(tos)));
+        }
+        op(_DO_STUFF, (tos -- res)) {
+            res = tos;
+        }
+        macro(OP) = _DO_STUFF;
+        macro(OP_SPECIALIZED) = _RECORD_TOS_TYPE + _DO_STUFF;
+        family(OP, INLINE_CACHE_ENTRIES_OP) = { OP_SPECIALIZED };
+        """
+        output = self.generate_tables(input)
+        # Family head must adopt the specialization's recorder.
+        self.assertIn("[OP] = {1, {_RECORD_TOS_TYPE_INDEX}}", output)
+        self.assertIn("[OP_SPECIALIZED] = {1, {_RECORD_TOS_TYPE_INDEX}}", output)
+        # Specialization consumes the slot directly (mask 0), no transform.
+        self.assert_slot_map_lines(output, "[OP_SPECIALIZED] = {1, 0, {0}}")
+        self.assertNotIn("_PyOpcode_RecordTransform_TOS_TYPE(", output)
+
+    def test_no_record_transform_when_only_base_records(self):
+        input = """
+        tier2 op(_RECORD_TOS, (tos -- tos)) {
+            RECORD_VALUE(PyStackRef_AsPyObjectBorrow(tos));
+        }
+        op(_DO_STUFF, (tos -- res)) {
+            res = tos;
+        }
+        macro(OP) = _RECORD_TOS + _DO_STUFF;
+        macro(OP_SPECIALIZED) = _DO_STUFF;
+        family(OP, INLINE_CACHE_ENTRIES_OP) = { OP_SPECIALIZED };
+        """
+        output = self.generate_tables(input)
+        # Family head records via _RECORD_TOS.
+        self.assertIn("[OP] = {1, {_RECORD_TOS_INDEX}}", output)
+        self.assertIn("[OP_SPECIALIZED] = {1, {_RECORD_TOS_INDEX}}", output)
+        # Specialization has no consumer slot map entry (it doesn't read it).
+        self.assertNotIn(
+            "[OP_SPECIALIZED] = {1,", self.get_slot_map_section(output)
+        )
+        # No transform helpers are generated.
+        self.assertNotIn("_PyOpcode_RecordTransform_TOS(", output)
+        self.assertNotIn("_PyOpcode_RecordTransform_TOS_TYPE", output)
+
     def test_family_member_maps_positional_recorders_to_family_slots(self):
         input = """
         tier2 op(_RECORD_TOS, (sub -- sub)) {
@@ -2243,7 +2312,12 @@ def test_family_head_records_union_of_member_recorders(self):
         macro(OP_SPECIALIZED) = _RECORD_TOS + _DO_STUFF;
         family(OP, INLINE_CACHE_ENTRIES_OP) = { OP_SPECIALIZED };
         """
+        analysis = self.analyze_input(input)
         output = self.generate_tables(input)
+        self.assertEqual(
+            analysis.families["OP"].get_member_record_names(),
+            ("_RECORD_TOS",),
+        )
         self.assertIn("[OP] = {1, {_RECORD_TOS_INDEX}}", output)
         self.assertIn("[OP_SPECIALIZED] = {1, {_RECORD_TOS_INDEX}}", output)
         self.assert_slot_map_lines(output, "[OP_SPECIALIZED] = {1, 0, {0}}")