Sync pre-release CPython 3.15 branch from GitHub (2026-07-16)

Summary:
Imported python/cpython `3.15.0b3+dev` from upstream rev [`38c3f11`](https://www.github.com/python/cpython/commit/38c3f112c383d1f61a3e2d2d4ff589a5ca570944) (committed 2026-07-16 18:59:43+00:00).

# Commit Info

- Base: (`3.15.0b3+dev`) - [`fd4c7a8`](https://www.github.com/python/cpython/commit/fd4c7a8d4d46c9b7db920a6b766d367ab22e6a1c) (commit date: 2026-07-15 18:15:24+00:00)
- Imported: (`3.15.0b3+dev`) - [`38c3f11`](https://www.github.com/python/cpython/commit/38c3f112c383d1f61a3e2d2d4ff589a5ca570944) (commit date: 2026-07-16 18:59:43+00:00)

# Noteworthy file changes

- Low-signal files (3 added) (NEWS.d, docs, .github)

Complete list of added/removed files: https://www.internalfb.com/intern/everpaste/?color=0&handle=GErqtCxXhL3TGGYGAIesG1Zxc5Jlbr0LAAAz

Differential Revision: D112487641

fbshipit-source-id: 56170695a5b8050ffbb764a1ccfd5b1e54358d15

Author: generatedunixname1734921407115435

Lib/test/test_free_threading/test_gc.py

@@ -124,6 +124,35 @@ def setter():
         finally:
             gc.set_threshold(*current_threshold)
 
+    def test_get_count(self):
+        class CyclicReference:
+            def __init__(self):
+                self.ref = self
+
+        NUM_ALLOCATORS = 7
+        NUM_READERS = 1
+        NUM_THREADS = NUM_ALLOCATORS + NUM_READERS
+        NUM_ITERS = 1000
+
+        barrier = threading.Barrier(NUM_THREADS)
+
+        def allocator():
+            barrier.wait()
+            for _ in range(NUM_ITERS):
+                CyclicReference()
+
+
+        def reader():
+            barrier.wait()
+            for _ in range(NUM_ITERS):
+                gc.get_count()
+
+        threads = [Thread(target=allocator) for _ in range(NUM_ALLOCATORS)]
+        threads.extend(Thread(target=reader) for _ in range(NUM_READERS))
+
+        with threading_helper.start_threads(threads):
+            pass
+
 
 if __name__ == "__main__":
     unittest.main()

Lib/test/test_free_threading/test_sys.py

@@ -4,6 +4,27 @@
 
 
 class SysModuleTest(unittest.TestCase):
+    @unittest.skipUnless(hasattr(sys, "setdlopenflags"),
+                         "test needs sys.setdlopenflags()")
+    def test_dlopenflags_concurrent(self):
+        # gh-151644: getdlopenflags() and setdlopenflags() must be safe to
+        # call concurrently in free-threaded builds.
+        original = sys.getdlopenflags()
+        self.addCleanup(sys.setdlopenflags, original)
+
+        # Use a small set of known-valid flag values to avoid integer overflow.
+        flag_values = [1, 2, 256, 257]
+
+        def worker(worker_id):
+            for i in range(20_000):
+                if worker_id % 2 == 0:
+                    sys.getdlopenflags()
+                else:
+                    sys.setdlopenflags(flag_values[worker_id % len(flag_values)])
+
+        workers = [lambda i=i: worker(i) for i in range(6)]
+        threading_helper.run_concurrently(workers)
+
     def test_int_max_str_digits_thread(self):
         # gh-151218: Check that it's safe to call get_int_max_str_digits() and
         # set_int_max_str_digits() in parallel. Previously, this test triggered

Misc/NEWS.d/next/Core_and_Builtins/2026-04-29-15-10-59.gh-issue-149162.BPPyrq.rst

@@ -0,0 +1,3 @@
+Fix a potential deadlock in :c:func:`PyUnicode_InternFromString` and other
+interning functions in the :term:`free-threaded build` when called from C++
+static local initializers.

Misc/NEWS.d/next/Core_and_Builtins/2026-05-26-00-06-30.gh-issue-150411.u-d-_5.rst

@@ -0,0 +1,2 @@
+Fix a data race in the free-threaded build when :func:`gc.get_count` reads
+the young generation allocation count while another thread updates it.

Misc/NEWS.d/next/Core_and_Builtins/2026-06-18-00-00-00.gh-issue-151644.5cFffN.rst

@@ -0,0 +1,4 @@
+Fix a data race in :func:`sys.setdlopenflags` and :func:`sys.getdlopenflags`
+when called concurrently in the free-threaded build. The underlying
+``_PyImport_GetDLOpenFlags`` and ``_PyImport_SetDLOpenFlags`` functions now
+use atomic load/store operations.

Modules/gcmodule.c

@@ -233,7 +233,7 @@ gc_get_count_impl(PyObject *module)
                          gcstate->generations[2].count);
 #else
     return Py_BuildValue("(iii)",
-                         gcstate->young.count,
+                         _Py_atomic_load_int_relaxed(&gcstate->young.count),
                          gcstate->old[0].count,
                          gcstate->old[1].count);
 #endif

Objects/unicodeobject.c

@@ -14344,7 +14344,7 @@ intern_common(PyInterpreterState *interp, PyObject *s /* stolen */,
     }
 #endif
 
-    FT_MUTEX_LOCK(INTERN_MUTEX);
+    FT_MUTEX_LOCK_FLAGS(INTERN_MUTEX, _Py_LOCK_DONT_DETACH);
     PyObject *t;
     {
         int res = PyDict_SetDefaultRef(interned, s, s, &t);

Python/import.c

@@ -911,13 +911,13 @@ _PyImport_SwapPackageContext(const char *newcontext)
 int
 _PyImport_GetDLOpenFlags(PyInterpreterState *interp)
 {
-    return DLOPENFLAGS(interp);
+    return FT_ATOMIC_LOAD_INT_RELAXED(DLOPENFLAGS(interp));
 }
 
 void
 _PyImport_SetDLOpenFlags(PyInterpreterState *interp, int new_val)
 {
-    DLOPENFLAGS(interp) = new_val;
+    FT_ATOMIC_STORE_INT_RELAXED(DLOPENFLAGS(interp), new_val);
 }
 #endif  // HAVE_DLOPEN