python
diff --git a/‎Include/cpython/pyatomic.h‎
Lines changed: 3 additions & 0 deletions b/‎Include/cpython/pyatomic.h‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎Include/cpython/pyatomic_gcc.h‎
Lines changed: 3 additions & 0 deletions b/‎Include/cpython/pyatomic_gcc.h‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎Include/cpython/pyatomic_msc.h‎
Lines changed: 11 additions & 0 deletions b/‎Include/cpython/pyatomic_msc.h‎
Lines changed: 11 additions & 0 deletions
diff --git a/‎Include/cpython/pyatomic_std.h‎
Lines changed: 7 additions & 0 deletions b/‎Include/cpython/pyatomic_std.h‎
Lines changed: 7 additions & 0 deletions
diff --git a/‎Include/internal/pycore_lock.h‎
Lines changed: 4 additions & 4 deletions b/‎Include/internal/pycore_lock.h‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎Objects/typeobject.c‎
Lines changed: 6 additions & 6 deletions b/‎Objects/typeobject.c‎
Lines changed: 6 additions & 6 deletions
diff --git a/‎Python/lock.c‎
Lines changed: 16 additions & 14 deletions b/‎Python/lock.c‎
Lines changed: 16 additions & 14 deletions
@@ -469,6 +469,9 @@ _Py_atomic_store_int_release(int *obj, int value);
 static inline int
 _Py_atomic_load_int_acquire(const int *obj);
 
+static inline uint32_t
+_Py_atomic_load_uint32_acquire(const uint32_t *obj);
+
 
 // --- _Py_atomic_fence ------------------------------------------------------
 
 
@@ -495,6 +495,9 @@ static inline int
 _Py_atomic_load_int_acquire(const int *obj)
 { return __atomic_load_n(obj, __ATOMIC_ACQUIRE); }
 
+static inline uint32_t
+_Py_atomic_load_uint32_acquire(const uint32_t *obj)
+{ return __atomic_load_n(obj, __ATOMIC_ACQUIRE); }
 
 // --- _Py_atomic_fence ------------------------------------------------------
 
 
@@ -938,6 +938,17 @@ _Py_atomic_load_int_acquire(const int *obj)
 #endif
 }
 
+static inline uint32_t
+_Py_atomic_load_uint32_acquire(const uint32_t *obj)
+{
+#if defined(_M_X64) || defined(_M_IX86)
+    return *(uint32_t volatile *)obj;
+#elif defined(_M_ARM64)
+    return (int)__ldar32((uint32_t volatile *)obj);
+#else
+#  error "no implementation of _Py_atomic_load_uint32_acquire"
+#endif
+}
 
 // --- _Py_atomic_fence ------------------------------------------------------
 
 
@@ -870,6 +870,13 @@ _Py_atomic_load_int_acquire(const int *obj)
                                 memory_order_acquire);
 }
 
+static inline uint32_t
+_Py_atomic_load_uint32_acquire(const uint32_t *obj)
+{
+    _Py_USING_STD;
+    return atomic_load_explicit((const _Atomic(uint32_t)*)obj,
+                                memory_order_acquire);
+}
 
 
 // --- _Py_atomic_fence ------------------------------------------------------
 
@@ -261,7 +261,7 @@ PyAPI_FUNC(void) _PyRWMutex_Unlock(_PyRWMutex *rwmutex);
 // The writer can also detect that the undelering data has not changed and abandon the write
 // and restore the previous sequence.
 typedef struct {
-    int sequence;
+    uint32_t sequence;
 } _PySeqLock;
 
 // Lock the sequence lock for the writer
@@ -275,15 +275,15 @@ PyAPI_FUNC(void) _PySeqLock_UnlockWrite(_PySeqLock *seqlock);
 PyAPI_FUNC(void) _PySeqLock_AbandonWrite(_PySeqLock *seqlock);
 
 // Begin a read operation and return the current sequence number.
-PyAPI_FUNC(int) _PySeqLock_BeginRead(_PySeqLock *seqlock);
+PyAPI_FUNC(uint32_t) _PySeqLock_BeginRead(_PySeqLock *seqlock);
 
 // End the read operation and confirm that the sequence number has not changed.
 // Returns 1 if the read was successful or 0 if the read should be re-tried.
-PyAPI_FUNC(int) _PySeqLock_EndRead(_PySeqLock *seqlock, int previous);
+PyAPI_FUNC(uint32_t) _PySeqLock_EndRead(_PySeqLock *seqlock, uint32_t previous);
 
 // Check if the lock was held during a fork and clear the lock.  Returns 1
 // if the lock was held and any associated datat should be cleared.
-PyAPI_FUNC(int) _PySeqLock_AfterFork(_PySeqLock *seqlock);
+PyAPI_FUNC(uint32_t) _PySeqLock_AfterFork(_PySeqLock *seqlock);
 
 #ifdef __cplusplus
 }
 
@@ -60,13 +60,13 @@ class object "PyObject *" "&PyBaseObject_Type"
 // in odd behaviors w.r.t. running with the GIL as the outer type lock could
 // be released and reacquired during a subclass update if there's contention
 // on the subclass lock.
-#define BEGIN_TYPE_LOCK()                                           \
-    {                                                               \
-    _PyCriticalSection _cs;                                         \
-    _PyCriticalSection_Begin(&_cs, &_PyRuntime.types.type_mutex);   \
+#define BEGIN_TYPE_LOCK()                                               \
+    {                                                                   \
+        _PyCriticalSection _cs;                                         \
+        _PyCriticalSection_Begin(&_cs, &_PyRuntime.types.type_mutex);   \
 
-#define END_TYPE_LOCK()                                             \
-        _PyCriticalSection_End(&_cs);                               \
+#define END_TYPE_LOCK()                                                 \
+        _PyCriticalSection_End(&_cs);                                   \
     }
 
 #define ASSERT_TYPE_LOCK_HELD() \
 
@@ -465,59 +465,61 @@ _PyRWMutex_Unlock(_PyRWMutex *rwmutex)
 void _PySeqLock_LockWrite(_PySeqLock *seqlock)
 {
     // lock the entry by setting by moving to an odd sequence number
-    int prev = seqlock->sequence;
+    uint32_t prev = _Py_atomic_load_uint32_relaxed(&seqlock->sequence);
     while (1) {
         if (SEQLOCK_IS_UPDATING(prev)) {
             // Someone else is currently updating the cache
             _Py_yield();
-            prev = _Py_atomic_load_int32_relaxed(&seqlock->sequence);
-        } else if (_Py_atomic_compare_exchange_int32(&seqlock->sequence, &prev, prev + 1)) {
+            prev = _Py_atomic_load_uint32_relaxed(&seqlock->sequence);
+        }
+        else if (_Py_atomic_compare_exchange_uint32(&seqlock->sequence, &prev, prev + 1)) {
             // We've locked the cache
             break;
-        } else {
+        }
+        else {
             _Py_yield();
         }
     }
 }
 
 void _PySeqLock_AbandonWrite(_PySeqLock *seqlock)
 {
-    int new_seq = seqlock->sequence - 1;
+    uint32_t new_seq = seqlock->sequence - 1;
     assert(!SEQLOCK_IS_UPDATING(new_seq));
-    _Py_atomic_exchange_int32(&seqlock->sequence, new_seq);
+    _Py_atomic_store_uint32(&seqlock->sequence, new_seq);
 }
 
 void _PySeqLock_UnlockWrite(_PySeqLock *seqlock)
 {
-    int new_seq = seqlock->sequence + 1;
+    uint32_t new_seq = seqlock->sequence + 1;
     assert(!SEQLOCK_IS_UPDATING(new_seq));
-    _Py_atomic_exchange_int32(&seqlock->sequence, new_seq);
+    _Py_atomic_store_uint32(&seqlock->sequence, new_seq);
 }
 
-int _PySeqLock_BeginRead(_PySeqLock *seqlock)
+uint32_t _PySeqLock_BeginRead(_PySeqLock *seqlock)
 {
-    int sequence = _Py_atomic_load_int_acquire(&seqlock->sequence);
+    uint32_t sequence = _Py_atomic_load_uint32_acquire(&seqlock->sequence);
     while (SEQLOCK_IS_UPDATING(sequence)) {
         _Py_yield();
-        sequence = _Py_atomic_load_int_acquire(&seqlock->sequence);
+        sequence = _Py_atomic_load_uint32_acquire(&seqlock->sequence);
     }
 
     return sequence;
 }
 
-int _PySeqLock_EndRead(_PySeqLock *seqlock, int previous)
+uint32_t _PySeqLock_EndRead(_PySeqLock *seqlock, uint32_t previous)
 {
     // Synchronize again and validate that the entry hasn't been updated
     // while we were readying the values.
-     if (_Py_atomic_load_int_acquire(&seqlock->sequence) == previous) {
+     if (_Py_atomic_load_uint32_acquire(&seqlock->sequence) == previous) {
         return 1;
      }
 
      _Py_yield();
      return 0;
 }
 
-int _PySeqLock_AfterFork(_PySeqLock *seqlock)
+uint32_t _PySeqLock_AfterFork(_PySeqLock *seqlock)
 {
     // Synchronize again and validate that the entry hasn't been updated
     // while we were readying the values.
Original file line number	Diff line number	Diff line change
`@@ -465,59 +465,61 @@ _PyRWMutex_Unlock(_PyRWMutex *rwmutex)`
`465`	`465`	`void _PySeqLock_LockWrite(_PySeqLock *seqlock)`
`466`	`466`	`{`
`467`	`467`	`// lock the entry by setting by moving to an odd sequence number`
`468`		`- int prev = seqlock->sequence;`
	`468`	`+ uint32_t prev = _Py_atomic_load_uint32_relaxed(&seqlock->sequence);`
`469`	`469`	`while (1) {`
`470`	`470`	`if (SEQLOCK_IS_UPDATING(prev)) {`
`471`	`471`	`// Someone else is currently updating the cache`
`472`	`472`	`_Py_yield();`
`473`		`- prev = _Py_atomic_load_int32_relaxed(&seqlock->sequence);`
`474`		`- } else if (_Py_atomic_compare_exchange_int32(&seqlock->sequence, &prev, prev + 1)) {`
	`473`	`+ prev = _Py_atomic_load_uint32_relaxed(&seqlock->sequence);`
	`474`	`+ }`
	`475`	`+ else if (_Py_atomic_compare_exchange_uint32(&seqlock->sequence, &prev, prev + 1)) {`
`475`	`476`	`// We've locked the cache`
`476`	`477`	`break;`
`477`		`- } else {`
	`478`	`+ }`
	`479`	`+ else {`
`478`	`480`	`_Py_yield();`
`479`	`481`	`}`
`480`	`482`	`}`
`481`	`483`	`}`
`482`	`484`
`483`	`485`	`void _PySeqLock_AbandonWrite(_PySeqLock *seqlock)`
`484`	`486`	`{`
`485`		`- int new_seq = seqlock->sequence - 1;`
	`487`	`+ uint32_t new_seq = seqlock->sequence - 1;`
`486`	`488`	`assert(!SEQLOCK_IS_UPDATING(new_seq));`
`487`		`- _Py_atomic_exchange_int32(&seqlock->sequence, new_seq);`
	`489`	`+ _Py_atomic_store_uint32(&seqlock->sequence, new_seq);`
`488`	`490`	`}`
`489`	`491`
`490`	`492`	`void _PySeqLock_UnlockWrite(_PySeqLock *seqlock)`
`491`	`493`	`{`
`492`		`- int new_seq = seqlock->sequence + 1;`
	`494`	`+ uint32_t new_seq = seqlock->sequence + 1;`
`493`	`495`	`assert(!SEQLOCK_IS_UPDATING(new_seq));`
`494`		`- _Py_atomic_exchange_int32(&seqlock->sequence, new_seq);`
	`496`	`+ _Py_atomic_store_uint32(&seqlock->sequence, new_seq);`
`495`	`497`	`}`
`496`	`498`
`497`		`-int _PySeqLock_BeginRead(_PySeqLock *seqlock)`
	`499`	`+uint32_t _PySeqLock_BeginRead(_PySeqLock *seqlock)`
`498`	`500`	`{`
`499`		`- int sequence = _Py_atomic_load_int_acquire(&seqlock->sequence);`
	`501`	`+ uint32_t sequence = _Py_atomic_load_uint32_acquire(&seqlock->sequence);`
`500`	`502`	`while (SEQLOCK_IS_UPDATING(sequence)) {`
`501`	`503`	`_Py_yield();`
`502`		`- sequence = _Py_atomic_load_int_acquire(&seqlock->sequence);`
	`504`	`+ sequence = _Py_atomic_load_uint32_acquire(&seqlock->sequence);`
`503`	`505`	`}`
`504`	`506`
`505`	`507`	`return sequence;`
`506`	`508`	`}`
`507`	`509`
`508`		`-int _PySeqLock_EndRead(_PySeqLock *seqlock, int previous)`
	`510`	`+uint32_t _PySeqLock_EndRead(_PySeqLock *seqlock, uint32_t previous)`
`509`	`511`	`{`
`510`	`512`	`// Synchronize again and validate that the entry hasn't been updated`
`511`	`513`	`// while we were readying the values.`
`512`		`- if (_Py_atomic_load_int_acquire(&seqlock->sequence) == previous) {`
	`514`	`+ if (_Py_atomic_load_uint32_acquire(&seqlock->sequence) == previous) {`
`513`	`515`	`return 1;`
`514`	`516`	`}`
`515`	`517`
`516`	`518`	`_Py_yield();`
`517`	`519`	`return 0;`
`518`	`520`	`}`
`519`	`521`
`520`		`-int _PySeqLock_AfterFork(_PySeqLock *seqlock)`
	`522`	`+uint32_t _PySeqLock_AfterFork(_PySeqLock *seqlock)`
`521`	`523`	`{`
`522`	`524`	`// Synchronize again and validate that the entry hasn't been updated`
`523`	`525`	`// while we were readying the values.`