Add GCC generalized atomic operation function

Author: atwwww

components/libc/cplusplus/cpp11/atomic_8.c

@@ -69,6 +69,84 @@ bool __atomic_compare_exchange_8(volatile void *ptr, volatile void *expected, ui
     return exchanged;
 }
 
+/**
+ * @param   size is the length of the value to load.
+ *
+ * @param   mem is the source memory to load the value from.
+ *
+ * @param   _return is the pointer to the space where the loaded value will be stored.
+ */
+void __atomic_load(size_t size,volatile void *mem,volatile void *_return, int model)
+{
+    rt_base_t level;
+    level = rt_hw_interrupt_disable();
+    memcpy(_return, mem, size);
+    rt_hw_interrupt_enable(level);
+}
+
+/**
+ * @param   size is the length of the value to store.
+ *
+ * @param   mem is the destination memory space to store the value.
+ *
+ * @param   val is the pointer to the value to store.
+ */
+void __atomic_store(size_t size,volatile void *mem,volatile void *val, int model)
+{
+    rt_base_t level;
+    level = rt_hw_interrupt_disable();
+    memcpy(mem, val, size);
+    rt_hw_interrupt_enable(level);
+}
+
+/**
+ * @param   size is the length of value to exchange.
+ *
+ * @param   mem is the destination space to exchange.
+ *
+ * @param   val is the pointer of value to exchange.
+ *
+ * @param   _return gives back the the value before exchanging.
+ */
+void __atomic_exchange(size_t size,volatile void *mem,volatile void *val,volatile void *_return, int model)
+{
+    rt_base_t level;
+    level = rt_hw_interrupt_disable();
+    memcpy(_return, mem, size);
+    memcpy(mem, val, size);
+    rt_hw_interrupt_enable(level);
+}
+
+/**
+ * @param   size is the length of value to operate.
+ *
+ * @param   obj is the destination value space to operate.
+ *
+ * @param   expected is the value to be compared with obj.
+ *
+ * @param   desired is the value pointer to be written into obj, under the condition that *expected equals *obj.
+ *
+ * @return  true if succeed in writing *desired into *obj; false if not.
+*/
+bool __atomic_compare_exchange(size_t size,volatile void *obj,volatile void *expected,volatile void *desired, int success, int failure)
+{
+    rt_base_t level;
+    volatile bool exchanged = false;
+    level = rt_hw_interrupt_disable();
+    if (memcmp(obj, expected, size) == 0)
+    {
+        memcpy(obj, desired, size);
+        exchanged = true;
+    }
+    else
+    {
+        memcpy(expected, obj, size);
+        exchanged = false;
+    }
+    rt_hw_interrupt_enable(level);
+    return exchanged;
+}
+
 #define __atomic_fetch_op_8(OPNAME, OP) \
 uint64_t __atomic_fetch_##OPNAME##_8(volatile void *ptr, uint64_t val, int memorder) {\
     volatile uint64_t* val_ptr = (volatile uint64_t*)ptr;\