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

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

commit 6bf1c380f2ee1509b1746d8945b9bf98686d52ba
Author: Bowen Wang <[email protected]>
AuthorDate: Mon Aug 31 21:07:27 2026 +0800

    libc/atomic: support inline arch atomic for tricore
    
    When CONFIG_LIBC_ATOMIC_ARCH is selected, atomic.h includes
    arch/atomic.h which provides static inline atomic_*_4
    operations using arch-specific helpers. This eliminates
    function call overhead for NuttX atomic API.
    
    For Tricore, the inline functions use hardware helpers
    (tricore_atomic_swap, tricore_atomic_cmpswap) implemented
    with inline assembly (swap.w, cmpswap.w), avoiding the iLLD
    dependency. The arch_atomic.c retains __atomic_*_4 symbols
    with external linkage for GCC libatomic ABI compatibility.
    
    Signed-off-by: Bowen Wang <[email protected]>
---
 arch/tricore/include/atomic.h           | 152 +++++++++++++++++++++
 include/nuttx/atomic.h                  |   8 +-
 libs/libc/machine/tricore/arch_atomic.c | 230 +-------------------------------
 3 files changed, 162 insertions(+), 228 deletions(-)

diff --git a/arch/tricore/include/atomic.h b/arch/tricore/include/atomic.h
new file mode 100644
index 00000000000..67aed769618
--- /dev/null
+++ b/arch/tricore/include/atomic.h
@@ -0,0 +1,152 @@
+/****************************************************************************
+ * arch/tricore/include/atomic.h
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.  The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the
+ * License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ ****************************************************************************/
+
+#ifndef __ARCH_TRICORE_INCLUDE_ATOMIC_H
+#define __ARCH_TRICORE_INCLUDE_ATOMIC_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+#include <nuttx/compiler.h>
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+#ifndef ARCH_ATOMIC_SPECIFIER
+#  define ARCH_ATOMIC_SPECIFIER static inline_function
+#endif
+
+#define ARCH_ATOMIC_STORE(func, t)                                       \
+  ARCH_ATOMIC_SPECIFIER                                                  \
+  void func(volatile void *ptr, t value, int memorder)                   \
+  {                                                                      \
+    tricore_atomic_swap(ptr, value);                                     \
+  }
+
+#define ARCH_ATOMIC_LOAD(func, t)                                        \
+  ARCH_ATOMIC_SPECIFIER                                                  \
+  t func(const volatile void *ptr, int memorder)                         \
+  {                                                                      \
+    return *(volatile t *)ptr;                                           \
+  }
+
+#define ARCH_ATOMIC_EXCHANGE(func, t)                                    \
+  ARCH_ATOMIC_SPECIFIER                                                  \
+  t func(volatile void *ptr, t value, int memorder)                      \
+  {                                                                      \
+    return tricore_atomic_swap(ptr, value);                              \
+  }
+
+#define ARCH_ATOMIC_COMPARE_EXCHANGE(func, t)                            \
+  ARCH_ATOMIC_SPECIFIER                                                  \
+  bool func(volatile void *ptr, volatile void *expect,                   \
+            t desired, bool weak, int success, int failure)              \
+  {                                                                      \
+    t old;                                                               \
+                                                                         \
+    old = tricore_atomic_cmpswap(ptr, desired, *(t *)expect);            \
+    if (old == *(t *)expect)                                             \
+      {                                                                  \
+        return true;                                                     \
+      }                                                                  \
+                                                                         \
+    *(t *)expect = old;                                                  \
+                                                                         \
+    return false;                                                        \
+  }
+
+#define ARCH_ATOMIC_FLAGS_TEST_AND_SET(func, t)                          \
+  ARCH_ATOMIC_SPECIFIER                                                  \
+  t func(volatile void *ptr, int memorder)                               \
+  {                                                                      \
+    return tricore_atomic_swap(ptr, 1);                                  \
+  }
+
+#define ARCH_ATOMIC_FETCH_OP(func, t, n, op)                             \
+  ARCH_ATOMIC_SPECIFIER                                                  \
+  t func(volatile void *ptr, t value, int memorder)                      \
+  {                                                                      \
+    t old_val;                                                           \
+                                                                         \
+    do                                                                   \
+      {                                                                  \
+        old_val = atomic_load_ ## n(ptr, memorder);                      \
+      }                                                                  \
+    while (tricore_atomic_cmpswap(ptr, old_val op value, old_val)        \
+           != old_val);                                                  \
+                                                                         \
+    return old_val;                                                      \
+  }
+
+#define ARCH_ATOMIC_DEFINE(prefix, t, n)                                 \
+  ARCH_ATOMIC_STORE(prefix ## _store_ ## n, t)                           \
+  ARCH_ATOMIC_LOAD(prefix ## _load_ ## n, t)                             \
+  ARCH_ATOMIC_EXCHANGE(prefix ## _exchange_ ## n, t)                     \
+  ARCH_ATOMIC_COMPARE_EXCHANGE(prefix ## _compare_exchange_ ## n, t)     \
+  ARCH_ATOMIC_FLAGS_TEST_AND_SET(prefix ## _flags_test_and_set_ ## n, t) \
+  ARCH_ATOMIC_FETCH_OP(prefix ## _fetch_add_ ## n, t, n, +)              \
+  ARCH_ATOMIC_FETCH_OP(prefix ## _fetch_sub_ ## n, t, n, -)              \
+  ARCH_ATOMIC_FETCH_OP(prefix ## _fetch_and_ ## n, t, n, &)              \
+  ARCH_ATOMIC_FETCH_OP(prefix ## _fetch_or_ ## n, t, n, |)               \
+  ARCH_ATOMIC_FETCH_OP(prefix ## _fetch_xor_ ## n, t, n, ^)
+
+/****************************************************************************
+ * Inline Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: tricore_atomic_swap
+ ****************************************************************************/
+
+always_inline_function
+static uint32_t tricore_atomic_swap(volatile void *addr, uint32_t value)
+{
+  uint32_t res;
+
+  __asm__ __volatile__ ("swap.w [%1]0, %2"
+                        : "=d"(res) : "a"(addr), "0"(value));
+  return res;
+}
+
+/****************************************************************************
+ * Name: tricore_atomic_cmpswap
+ ****************************************************************************/
+
+always_inline_function
+static uint32_t tricore_atomic_cmpswap(volatile void *addr, uint32_t value,
+                                       uint32_t condition)
+{
+  uint64_t reg64 = value | ((uint64_t)condition << 32);
+
+  __asm__ __volatile__ ("cmpswap.w [%1]0, %A0"
+                        : "+d" (reg64)
+                        : "a" (addr)
+                        : "memory");
+  return (uint32_t)reg64;
+}
+
+ARCH_ATOMIC_DEFINE(atomic, int32_t, 4)
+
+#endif /* __ARCH_TRICORE_INCLUDE_ATOMIC_H */
diff --git a/include/nuttx/atomic.h b/include/nuttx/atomic.h
index f9734bb4032..e6e90d991a1 100644
--- a/include/nuttx/atomic.h
+++ b/include/nuttx/atomic.h
@@ -27,9 +27,15 @@
  * Included Files
  ****************************************************************************/
 
+#include <nuttx/config.h>
+
 #include <stdbool.h>
 #include <stdint.h>
 
+#ifdef CONFIG_LIBC_ATOMIC_ARCH
+#  include <arch/atomic.h>
+#endif
+
 /****************************************************************************
  * Pre-processor Definitions
  ****************************************************************************/
@@ -290,7 +296,7 @@ extern "C"
 {
 #endif
 
-#ifndef CONFIG_LIBC_ATOMIC_TOOLCHAIN
+#if !defined(CONFIG_LIBC_ATOMIC_TOOLCHAIN) && !defined(CONFIG_LIBC_ATOMIC_ARCH)
 void atomic_store_4(FAR volatile void *ptr, int32_t value, int memorder);
 void atomic_store_8(FAR volatile void *ptr, int64_t value, int memorder);
 int32_t atomic_load_4(FAR const volatile void *ptr, int memorder);
diff --git a/libs/libc/machine/tricore/arch_atomic.c 
b/libs/libc/machine/tricore/arch_atomic.c
index dd4e83e697e..a834d5ad975 100644
--- a/libs/libc/machine/tricore/arch_atomic.c
+++ b/libs/libc/machine/tricore/arch_atomic.c
@@ -26,236 +26,12 @@
 
 #include <nuttx/config.h>
 
-#include <nuttx/atomic.h>
-#include <nuttx/compiler.h>
-
-/****************************************************************************
- * Pre-processor Definitions
- ****************************************************************************/
-
-#define ARCH_ATOMIC_STORE_4(func)                                       \
-                                                                        \
-  void func(volatile void *ptr, int32_t value, int memorder)            \
-  {                                                                     \
-    tricore_atomic_swap(ptr, value);                                    \
-  }
-
-#define ARCH_ATOMIC_LOAD_4(func)                                        \
-                                                                        \
-  int32_t func(const volatile void *ptr, int memorder)                  \
-  {                                                                     \
-    return *(volatile uint32_t *)ptr;                                   \
-  }
-
-#define ARCH_ATOMIC_EXCHANGE_4(func)                                    \
-                                                                        \
-  int32_t func(volatile void *ptr, int32_t value, int memorder)         \
-  {                                                                     \
-    return tricore_atomic_swap(ptr, value);                             \
-  }
-
-#define ARCH_ATOMIC_COMPARE_EXCHANGE_4(func)                            \
-                                                                        \
-  bool func(volatile void *ptr, volatile void *expect,                  \
-            int32_t desired, bool weak, int success, int failure)       \
-  {                                                                     \
-    int32_t old;                                                        \
-                                                                        \
-    old = tricore_atomic_cmpswap(ptr, desired, *(int32_t *)expect);     \
-    if (old == *(int32_t *)expect)                                      \
-      {                                                                 \
-        return true;                                                    \
-      }                                                                 \
-                                                                        \
-    *(int32_t *)expect = old;                                           \
-                                                                        \
-    return false;                                                       \
-  }
-
-#define ARCH_ATOMIC_FLAGS_TEST_AND_SET_4(func)                          \
-                                                                        \
-  int32_t func(volatile void *ptr, int memorder)                        \
-  {                                                                     \
-    return tricore_atomic_swap(ptr, 1);                                 \
-  }
-
-#define ARCH_ATOMIC_FETCH_ADD_4(func)                                   \
-                                                                        \
-  int32_t func(volatile void *ptr, int32_t value, int memorder)         \
-  {                                                                     \
-    int32_t old_val;                                                    \
-                                                                        \
-    do                                                                  \
-      {                                                                 \
-        old_val = atomic_load_4(ptr, memorder);                         \
-      }                                                                 \
-    while (tricore_atomic_cmpswap(ptr, old_val + value, old_val)        \
-           != old_val);                                                 \
-                                                                        \
-    return old_val;                                                     \
-  }
-
-#define ARCH_ATOMIC_FETCH_SUB_4(func)                                   \
-                                                                        \
-  int32_t func(volatile void *ptr, int32_t value, int memorder)         \
-  {                                                                     \
-    int32_t old_val;                                                    \
-                                                                        \
-    do                                                                  \
-      {                                                                 \
-        old_val = atomic_load_4(ptr, memorder);                         \
-      }                                                                 \
-    while (tricore_atomic_cmpswap(ptr, old_val - value, old_val)        \
-           != old_val);                                                 \
-                                                                        \
-    return old_val;                                                     \
-  }
-
-#define ARCH_ATOMIC_FETCH_AND_4(func)                                   \
-                                                                        \
-  int32_t func(volatile void *ptr, int32_t value, int memorder)         \
-  {                                                                     \
-    int32_t old_val;                                                    \
-                                                                        \
-    do                                                                  \
-      {                                                                 \
-        old_val = atomic_load_4(ptr, memorder);                         \
-      }                                                                 \
-    while (tricore_atomic_cmpswap(ptr, old_val & value, old_val)        \
-           != old_val);                                                 \
-                                                                        \
-    return old_val;                                                     \
-  }
-
-#define ARCH_ATOMIC_FETCH_OR_4(func)                                    \
-                                                                        \
-  int32_t func(volatile void *ptr, int32_t value, int memorder)         \
-  {                                                                     \
-    int32_t old_val;                                                    \
-                                                                        \
-    do                                                                  \
-      {                                                                 \
-        old_val = atomic_load_4(ptr, memorder);                         \
-      }                                                                 \
-    while (tricore_atomic_cmpswap(ptr, old_val | value, old_val)        \
-           != old_val);                                                 \
-                                                                        \
-    return old_val;                                                     \
-  }
-
-#define ARCH_ATOMIC_FETCH_XOR_4(func)                                   \
-                                                                        \
-  int32_t func(volatile void *ptr, int32_t value, int memorder)         \
-  {                                                                     \
-    int32_t old_val;                                                    \
-                                                                        \
-    do                                                                  \
-      {                                                                 \
-        old_val = atomic_load_4(ptr, memorder);                         \
-      }                                                                 \
-    while (tricore_atomic_cmpswap(ptr, old_val ^ value, old_val)        \
-           != old_val);                                                 \
-                                                                        \
-    return old_val;                                                     \
-  }
-
-/****************************************************************************
- * Private Functions
- ****************************************************************************/
-
-always_inline_function
-static uint32_t tricore_atomic_swap(volatile void *addr, uint32_t value)
-{
-  uint32_t res;
-
-  __asm__ volatile ("swap.w [%1]0, %2"
-                    : "=d"(res) : "a"(addr), "0"(value));
-  return res;
-}
+#define ARCH_ATOMIC_SPECIFIER
 
-always_inline_function
-static uint32_t tricore_atomic_cmpswap(volatile void *addr, uint32_t value,
-                                       uint32_t condition)
-{
-  uint64_t reg64 = value | ((uint64_t)condition << 32);
-
-  __asm__ __volatile__ ("cmpswap.w [%1]0, %A0"
-                        : "+d" (reg64)
-                        : "a" (addr)
-                        : "memory");
-  return (uint32_t)reg64;
-}
+#include <nuttx/atomic.h>
 
 /****************************************************************************
  * Public Functions
  ****************************************************************************/
 
-/****************************************************************************
- * Name: atomic_store_4
- ****************************************************************************/
-
-ARCH_ATOMIC_STORE_4(__atomic_store_4)
-ARCH_ATOMIC_STORE_4(atomic_store_4)
-
-/****************************************************************************
- * Name: atomic_load_4
- ****************************************************************************/
-
-ARCH_ATOMIC_LOAD_4(__atomic_load_4)
-ARCH_ATOMIC_LOAD_4(atomic_load_4)
-
-/****************************************************************************
- * Name: atomic_exchange_4
- ****************************************************************************/
-
-ARCH_ATOMIC_EXCHANGE_4(__atomic_exchange_4)
-ARCH_ATOMIC_EXCHANGE_4(atomic_exchange_4)
-
-/****************************************************************************
- * Name: atomic_compare_exchange_4
- ****************************************************************************/
-
-ARCH_ATOMIC_COMPARE_EXCHANGE_4(__atomic_compare_exchange_4)
-ARCH_ATOMIC_COMPARE_EXCHANGE_4(atomic_compare_exchange_4)
-
-/****************************************************************************
- * Name: atomic_flag_test_and_set_4
- ****************************************************************************/
-
-ARCH_ATOMIC_FLAGS_TEST_AND_SET_4(__atomic_flags_test_and_set_4)
-ARCH_ATOMIC_FLAGS_TEST_AND_SET_4(atomic_flags_test_and_set_4)
-
-/****************************************************************************
- * Name: atomic_fetch_add_4
- ****************************************************************************/
-
-ARCH_ATOMIC_FETCH_ADD_4(__atomic_fetch_add_4)
-ARCH_ATOMIC_FETCH_ADD_4(atomic_fetch_add_4)
-
-/****************************************************************************
- * Name: atomic_fetch_sub_4
- ****************************************************************************/
-
-ARCH_ATOMIC_FETCH_SUB_4(__atomic_fetch_sub_4)
-ARCH_ATOMIC_FETCH_SUB_4(atomic_fetch_sub_4)
-
-/****************************************************************************
- * Name: atomic_fetch_and_4
- ****************************************************************************/
-
-ARCH_ATOMIC_FETCH_AND_4(__atomic_fetch_and_4)
-ARCH_ATOMIC_FETCH_AND_4(atomic_fetch_and_4)
-
-/****************************************************************************
- * Name: atomic_fetch_or_4
- ****************************************************************************/
-
-ARCH_ATOMIC_FETCH_OR_4(__atomic_fetch_or_4)
-ARCH_ATOMIC_FETCH_OR_4(atomic_fetch_or_4)
-
-/****************************************************************************
- * Name: atomic_fetch_xor_4
- ****************************************************************************/
-
-ARCH_ATOMIC_FETCH_XOR_4(__atomic_fetch_xor_4)
-ARCH_ATOMIC_FETCH_XOR_4(atomic_fetch_xor_4)
+ARCH_ATOMIC_DEFINE(__atomic, int32_t, 4)

Reply via email to