This is an automated email from the ASF dual-hosted git repository.

xiaoxiang781216 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/nuttx.git

commit fa9bf969d067855ca51ba6d08ae116f2f4e26127
Author: Marco Casaroli <[email protected]>
AuthorDate: Sun Nov 15 08:26:27 2026 +0100

    include/nuttx/atomic.h: Make atomic_ptr_t pointer sized on 16-bit targets.
    
    atomic_ptr_t was atomic_t, 32 bits, also where a pointer is 16 bits, as
    on AVR.  atomic_ptr_read() of a variable as wide as a pointer then read
    two more bytes, and atomic_ptr_set() wrote them.
    
    When UINTPTR_MAX <= UINT16_MAX, atomic_ptr_t is now a 16-bit atomic, and
    the atomic_ptr_*() operations are the GCC __atomic builtins on 2 bytes.
    Where the CPU has no atomic instructions, as on AVR, GCC calls the
    __atomic_*_2 functions that libs/libc/machine/arch_atomic.c already
    provides.  Nothing uses atomic_ptr_t yet, so no user changes.
    
    Assisted-by: Claude Code:claude-opus-5-5
    Signed-off-by: Marco Casaroli <[email protected]>
---
 include/nuttx/atomic.h | 62 ++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 60 insertions(+), 2 deletions(-)

diff --git a/include/nuttx/atomic.h b/include/nuttx/atomic.h
index a9471bc4c71..cff33d07f1e 100644
--- a/include/nuttx/atomic.h
+++ b/include/nuttx/atomic.h
@@ -224,7 +224,7 @@
 #define atomic_ptr_try_cmpxchg_relaxed(obj, expected, desired) \
   atomic64_try_cmpxchg_relaxed(obj, expected, desired)
 
-#else /* UINTPTR_MAX <= UINT32_MAX */
+#elif UINTPTR_MAX > UINT16_MAX
 
 #define atomic_ptr_set(obj, val)            atomic_set(obj, val)
 #define atomic_ptr_set_release(obj, val)    atomic_set_release(obj, val)
@@ -275,6 +275,62 @@
 #define atomic_ptr_try_cmpxchg_relaxed(obj, expected, desired) \
   atomic_try_cmpxchg_relaxed(obj, expected, desired)
 
+#else /* UINTPTR_MAX <= UINT16_MAX */
+
+/* A pointer is 16 bits, as on AVR.  These are GCC builtins: where the CPU
+ * has no atomic instructions, they call the __atomic_*_2 functions of
+ * libs/libc/machine/arch_atomic.c.
+ */
+
+#define atomic_ptr_set(obj, val)            __atomic_store_n(obj, val, 
__ATOMIC_RELAXED)
+#define atomic_ptr_set_release(obj, val)    __atomic_store_n(obj, val, 
__ATOMIC_RELEASE)
+#define atomic_ptr_read(obj)                __atomic_load_n(obj, 
__ATOMIC_RELAXED)
+#define atomic_ptr_read_acquire(obj)        __atomic_load_n(obj, 
__ATOMIC_ACQUIRE)
+#define atomic_ptr_add(obj, val)            __atomic_fetch_add(obj, val, 
__ATOMIC_ACQ_REL)
+#define atomic_ptr_add_acquire(obj, val)    __atomic_fetch_add(obj, val, 
__ATOMIC_ACQUIRE)
+#define atomic_ptr_add_release(obj, val)    __atomic_fetch_add(obj, val, 
__ATOMIC_RELEASE)
+#define atomic_ptr_add_relaxed(obj, val)    __atomic_fetch_add(obj, val, 
__ATOMIC_RELAXED)
+#define atomic_ptr_sub(obj, val)            __atomic_fetch_sub(obj, val, 
__ATOMIC_ACQ_REL)
+#define atomic_ptr_sub_acquire(obj, val)    __atomic_fetch_sub(obj, val, 
__ATOMIC_ACQUIRE)
+#define atomic_ptr_sub_release(obj, val)    __atomic_fetch_sub(obj, val, 
__ATOMIC_RELEASE)
+#define atomic_ptr_sub_relaxed(obj, val)    __atomic_fetch_sub(obj, val, 
__ATOMIC_RELAXED)
+#define atomic_ptr_and(obj, val)            __atomic_fetch_and(obj, val, 
__ATOMIC_ACQ_REL)
+#define atomic_ptr_and_acquire(obj, val)    __atomic_fetch_and(obj, val, 
__ATOMIC_ACQUIRE)
+#define atomic_ptr_and_release(obj, val)    __atomic_fetch_and(obj, val, 
__ATOMIC_RELEASE)
+#define atomic_ptr_and_relaxed(obj, val)    __atomic_fetch_and(obj, val, 
__ATOMIC_RELAXED)
+#define atomic_ptr_or(obj, val)             __atomic_fetch_or(obj, val, 
__ATOMIC_ACQ_REL)
+#define atomic_ptr_or_acquire(obj, val)     __atomic_fetch_or(obj, val, 
__ATOMIC_ACQUIRE)
+#define atomic_ptr_or_release(obj, val)     __atomic_fetch_or(obj, val, 
__ATOMIC_RELEASE)
+#define atomic_ptr_or_relaxed(obj, val)     __atomic_fetch_or(obj, val, 
__ATOMIC_RELAXED)
+#define atomic_ptr_xor(obj, val)            __atomic_fetch_xor(obj, val, 
__ATOMIC_ACQ_REL)
+#define atomic_ptr_xor_acquire(obj, val)    __atomic_fetch_xor(obj, val, 
__ATOMIC_ACQUIRE)
+#define atomic_ptr_xor_release(obj, val)    __atomic_fetch_xor(obj, val, 
__ATOMIC_RELEASE)
+#define atomic_ptr_xor_relaxed(obj, val)    __atomic_fetch_xor(obj, val, 
__ATOMIC_RELAXED)
+#define atomic_ptr_xchg(obj, val)           __atomic_exchange_n(obj, val, 
__ATOMIC_ACQ_REL)
+#define atomic_ptr_xchg_acquire(obj, val)   __atomic_exchange_n(obj, val, 
__ATOMIC_ACQUIRE)
+#define atomic_ptr_xchg_release(obj, val)   __atomic_exchange_n(obj, val, 
__ATOMIC_RELEASE)
+#define atomic_ptr_xchg_relaxed(obj, val)   __atomic_exchange_n(obj, val, 
__ATOMIC_RELAXED)
+#define atomic_ptr_cmpxchg(obj, expected, desired) \
+  __atomic_compare_exchange_n(obj, (FAR int16_t *)expected, desired, false, 
__ATOMIC_ACQ_REL, __ATOMIC_RELAXED)
+#define atomic_ptr_cmpxchg_acquire(obj, expected, desired) \
+  __atomic_compare_exchange_n(obj, (FAR int16_t *)expected, desired, false, 
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED)
+#define atomic_ptr_cmpxchg_release(obj, expected, desired) \
+  __atomic_compare_exchange_n(obj, (FAR int16_t *)expected, desired, false, 
__ATOMIC_RELEASE, __ATOMIC_RELAXED)
+#define atomic_ptr_cmpxchg_release_acquire(obj, expected, desired) \
+  __atomic_compare_exchange_n(obj, (FAR int16_t *)expected, desired, false, 
__ATOMIC_RELEASE, __ATOMIC_ACQUIRE)
+#define atomic_ptr_cmpxchg_relaxed(obj, expected, desired) \
+  __atomic_compare_exchange_n(obj, (FAR int16_t *)expected, desired, false, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED)
+#define atomic_ptr_try_cmpxchg(obj, expected, desired) \
+  __atomic_compare_exchange_n(obj, (FAR int16_t *)expected, desired, true, 
__ATOMIC_ACQ_REL, __ATOMIC_RELAXED)
+#define atomic_ptr_try_cmpxchg_acquire(obj, expected, desired) \
+  __atomic_compare_exchange_n(obj, (FAR int16_t *)expected, desired, true, 
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED)
+#define atomic_ptr_try_cmpxchg_release(obj, expected, desired) \
+  __atomic_compare_exchange_n(obj, (FAR int16_t *)expected, desired, true, 
__ATOMIC_RELEASE, __ATOMIC_RELAXED)
+#define atomic_ptr_try_cmpxchg_release_acquire(obj, expected, desired) \
+  __atomic_compare_exchange_n(obj, (FAR int16_t *)expected, desired, true, 
__ATOMIC_RELEASE, __ATOMIC_ACQUIRE)
+#define atomic_ptr_try_cmpxchg_relaxed(obj, expected, desired) \
+  __atomic_compare_exchange_n(obj, (FAR int16_t *)expected, desired, true, 
__ATOMIC_RELAXED, __ATOMIC_RELAXED)
+
 #endif /* UINTPTR_MAX > UINT32_MAX */
 
 #define ARCH_ATOMIC_DECLARE(prefix, t, n)                              \
@@ -320,8 +376,10 @@ typedef __Atomic(int64_t) atomic64_t;
 
 #if UINTPTR_MAX > UINT32_MAX
 typedef atomic64_t atomic_ptr_t;
-#else
+#elif UINTPTR_MAX > UINT16_MAX
 typedef atomic_t atomic_ptr_t;
+#else
+typedef __Atomic(int16_t) atomic_ptr_t;
 #endif
 
 /****************************************************************************

Reply via email to