build: Update c89atomic

Signed-off-by: Andrew Opalach <andrew@akon.city>

4 files changed, 38 insertions, 39 deletions

diff --git a/include/al/atomic.h b/include/al/atomic.h
index f24a155..75308f2 100644
--- a/include/al/atomic.h
+++ b/include/al/atomic.h
@@ -16,12 +16,11 @@
 #define AL_PASTER(X, Y) AL_PASTER_EVALUATOR(X, Y)
 
 #define atomic(T) AL_PASTER(_al_atomic, T)
-
-#define al_atomic_load(T) AL_PASTER(_al_atomic_load, T)
-#define al_atomic_store(T) AL_PASTER(_al_atomic_store, T)
-#define al_atomic_add(T) AL_PASTER(_al_atomic_add, T)
-#define al_atomic_sub(T) AL_PASTER(_al_atomic_sub, T)
-#define al_atomic_compare_and_swap(T) AL_PASTER(_al_atomic_compare_and_swap, T)
+#define atomic_load(T) AL_PASTER(_al_atomic_load, T)
+#define atomic_store(T) AL_PASTER(_al_atomic_store, T)
+#define atomic_add(T) AL_PASTER(_al_atomic_add, T)
+#define atomic_compare_and_swap(T) AL_PASTER(_al_atomic_compare_and_swap, T)
+#define atomic_sub(T) AL_PASTER(_al_atomic_sub, T)
 
 // Special case for pointers.
 #define _al_atomic_load_void(p, order) c89atomic_load_explicit_ptr((volatile void **)p, order)
@@ -33,25 +32,25 @@ typedef f32 c89atomic_f32;
 
 #define AL_ATOMIC_DEFINE(T, C, S) \
     typedef c89atomic_##C atomic(T); \
-    static inline T al_atomic_load(T)(atomic(T) *a, s32 order) \
+    static inline T atomic_load(T)(atomic(T) *a, s32 order) \
     { \
         return c89atomic_load_explicit_##S(a, order); \
     } \
-    static inline void al_atomic_store(T)(atomic(T) *a, T value, s32 order) \
+    static inline void atomic_store(T)(atomic(T) *a, T value, s32 order) \
     { \
         c89atomic_store_explicit_##S(a, value, order); \
     } \
-    static inline T al_atomic_compare_and_swap(T)(atomic(T) *a, T expected, T desired) \
+    static inline T atomic_compare_and_swap(T)(atomic(T) *a, T expected, T desired) \
     { \
         return c89atomic_compare_and_swap_##S(a, expected, desired); \
     }
 
 #define AL_ATOMIC_DEFINE_EXT(T, C, S) \
-    static inline T al_atomic_add(T)(atomic(T) *a, T value, s32 order) \
+    static inline T atomic_add(T)(atomic(T) *a, T value, s32 order) \
     { \
         return c89atomic_fetch_add_explicit_##S(a, value, order); \
     } \
-    static inline T al_atomic_sub(T)(atomic(T) *a, T value, s32 order) \
+    static inline T atomic_sub(T)(atomic(T) *a, T value, s32 order) \
     { \
         return c89atomic_fetch_sub_explicit_##S(a, value, order); \
     }
@@ -77,7 +76,7 @@ AL_ATOMIC_DEFINE(u8, uint8, 8);
 AL_ATOMIC_DEFINE(s8, int8, i8);
 AL_ATOMIC_DEFINE(f64, f64, f64);
 AL_ATOMIC_DEFINE(f32, f32, f32);
-AL_ATOMIC_DEFINE(bool, bool, 8);
+AL_ATOMIC_DEFINE(bool, bool, 32);
 
 static inline f32 _al_atomic_add_f32(atomic(f32) *a, f32 value, s32 order)
 {
diff --git a/src/ring_buffer.c b/src/ring_buffer.c
index 5c4307f..84300b6 100644
--- a/src/ring_buffer.c
+++ b/src/ring_buffer.c
@@ -25,20 +25,20 @@ static inline void add(struct al_ring_buffer *buf, u8 **v, u8 *ptr, ptrdiff_t n)
     ptr += n;
     al_assert(ptr <= buf->end);
     if (ptr == buf->end) ptr = buf->start;
-    al_atomic_store(void)(v, ptr, AL_ATOMIC_RELEASE);
+    atomic_store(void)(v, ptr, AL_ATOMIC_RELEASE);
 }
 
 ptrdiff_t al_ring_buffer_space(struct al_ring_buffer *buf)
 {
-    u8 *wp = (u8 *)al_atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
-    u8 *rp = previous(buf, (u8 *)al_atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED));
+    u8 *wp = (u8 *)atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
+    u8 *rp = previous(buf, (u8 *)atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED));
     return (wp <= rp) ? rp - wp : (buf->end - wp) + (rp - buf->start);
 }
 
 u8 *al_ring_buffer_write_chunk(struct al_ring_buffer *buf, ptrdiff_t *size)
 {
-    u8 *wp = (u8 *)al_atomic_load(void)(&buf->write, AL_ATOMIC_ACQUIRE);
-    u8 *rp = previous(buf, (u8 *)al_atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED));
+    u8 *wp = (u8 *)atomic_load(void)(&buf->write, AL_ATOMIC_ACQUIRE);
+    u8 *rp = previous(buf, (u8 *)atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED));
     *size = ((wp <= rp) ? rp : buf->end) - wp;
     return wp;
 }
@@ -50,15 +50,15 @@ void al_ring_buffer_append(struct al_ring_buffer *buf, u8 *ptr, ptrdiff_t n)
 
 ptrdiff_t al_ring_buffer_occupied(struct al_ring_buffer *buf)
 {
-    u8 *rp = (u8 *)al_atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED);
-    u8 *wp = (u8 *)al_atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
+    u8 *rp = (u8 *)atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED);
+    u8 *wp = (u8 *)atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
     return (rp <= wp) ? wp - rp : (buf->end - rp) + (wp - buf->start);
 }
 
 u8 *al_ring_buffer_read_chunk(struct al_ring_buffer *buf, ptrdiff_t *size)
 {
-    u8 *rp = (u8 *)al_atomic_load(void)(&buf->read, AL_ATOMIC_ACQUIRE);
-    u8 *wp = (u8 *)al_atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
+    u8 *rp = (u8 *)atomic_load(void)(&buf->read, AL_ATOMIC_ACQUIRE);
+    u8 *wp = (u8 *)atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
     *size = ((rp <= wp) ? wp : buf->end) - rp;
     return rp;
 }
@@ -70,8 +70,8 @@ void al_ring_buffer_consume(struct al_ring_buffer *buf, u8 *ptr, ptrdiff_t n)
 
 ptrdiff_t al_ring_buffer_write(struct al_ring_buffer *buf, u8 *data, ptrdiff_t n)
 {
-    u8 *wp = (u8 *)al_atomic_load(void)(&buf->write, AL_ATOMIC_ACQUIRE);
-    u8 *rp = previous(buf, (u8 *)al_atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED));
+    u8 *wp = (u8 *)atomic_load(void)(&buf->write, AL_ATOMIC_ACQUIRE);
+    u8 *rp = previous(buf, (u8 *)atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED));
 
     ptrdiff_t size = MIN(((wp <= rp) ? rp : buf->end) - wp, n);
     al_memcpy(wp, data, (size_t)size);
@@ -84,15 +84,15 @@ ptrdiff_t al_ring_buffer_write(struct al_ring_buffer *buf, u8 *data, ptrdiff_t n
         size += wrap;
     }
 
-    al_atomic_store(void)(&buf->write, wp, AL_ATOMIC_RELEASE);
+    atomic_store(void)(&buf->write, wp, AL_ATOMIC_RELEASE);
 
     return size;
 }
 
 ptrdiff_t al_ring_buffer_read(struct al_ring_buffer *buf, u8 *ptr, ptrdiff_t n)
 {
-    u8 *rp = (u8 *)al_atomic_load(void)(&buf->read, AL_ATOMIC_ACQUIRE);
-    u8 *wp = (u8 *)al_atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
+    u8 *rp = (u8 *)atomic_load(void)(&buf->read, AL_ATOMIC_ACQUIRE);
+    u8 *wp = (u8 *)atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
 
     ptrdiff_t size = MIN(((rp <= wp) ? wp : buf->end) - rp, n);
     al_memcpy(ptr, rp, (size_t)size);
@@ -105,15 +105,15 @@ ptrdiff_t al_ring_buffer_read(struct al_ring_buffer *buf, u8 *ptr, ptrdiff_t n)
         size += wrap;
     }
 
-    al_atomic_store(void)(&buf->read, rp, AL_ATOMIC_RELEASE);
+    atomic_store(void)(&buf->read, rp, AL_ATOMIC_RELEASE);
 
     return size;
 }
 
 ptrdiff_t al_ring_buffer_peek(struct al_ring_buffer *buf, u8 *ptr, ptrdiff_t offset, ptrdiff_t n)
 {
-    u8 *rp = (u8 *)al_atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED);
-    u8 *wp = (u8 *)al_atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
+    u8 *rp = (u8 *)atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED);
+    u8 *wp = (u8 *)atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
 
     ptrdiff_t size;
     if (rp <= wp) {
@@ -144,8 +144,8 @@ ptrdiff_t al_ring_buffer_peek(struct al_ring_buffer *buf, u8 *ptr, ptrdiff_t off
 
 ptrdiff_t al_ring_buffer_discard(struct al_ring_buffer *buf, ptrdiff_t n)
 {
-    u8 *rp = (u8 *)al_atomic_load(void)(&buf->read, AL_ATOMIC_ACQUIRE);
-    u8 *wp = (u8 *)al_atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
+    u8 *rp = (u8 *)atomic_load(void)(&buf->read, AL_ATOMIC_ACQUIRE);
+    u8 *wp = (u8 *)atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
 
     ptrdiff_t discard = MIN(((rp <= wp) ? wp : buf->end) - rp, n);
     rp += discard;
@@ -156,7 +156,7 @@ ptrdiff_t al_ring_buffer_discard(struct al_ring_buffer *buf, ptrdiff_t n)
         discard += wrap;
     }
 
-    al_atomic_store(void)(&buf->read, rp, AL_ATOMIC_RELEASE);
+    atomic_store(void)(&buf->read, rp, AL_ATOMIC_RELEASE);
 
     return discard;
 }
@@ -164,6 +164,6 @@ ptrdiff_t al_ring_buffer_discard(struct al_ring_buffer *buf, ptrdiff_t n)
 // Not thread-safe.
 void al_ring_buffer_reset(struct al_ring_buffer *buf)
 {
-    al_atomic_store(void)(&buf->read, buf->start, AL_ATOMIC_RELAXED);
-    al_atomic_store(void)(&buf->write, buf->start, AL_ATOMIC_RELAXED);
+    atomic_store(void)(&buf->read, buf->start, AL_ATOMIC_RELAXED);
+    atomic_store(void)(&buf->write, buf->start, AL_ATOMIC_RELAXED);
 }
diff --git a/subprojects/c89atomic.wrap b/subprojects/c89atomic.wrap
index dcd30a5..2ea66b7 100644
--- a/subprojects/c89atomic.wrap
+++ b/subprojects/c89atomic.wrap
@@ -1,6 +1,6 @@
 [wrap-git]
-directory = c89atomic-a9f4fa0
+directory = c89atomic-8e3cd3c
 url = https://github.com/mackron/c89atomic.git
-revision = a9f4fa0083e45a50982ad8dfd75da26c642f9f92
+revision = 8e3cd3ca8acca3b286fb07ed759467e51ce403c9
 depth = 1
 patch_directory = c89atomic
diff --git a/tests/ring_buffer.c b/tests/ring_buffer.c
index 5f310f2..f9e99c0 100644
--- a/tests/ring_buffer.c
+++ b/tests/ring_buffer.c
@@ -20,8 +20,8 @@ static bool ring_buffer_test_init(void)
 
     AL_TEST_EQ(buf.start, buffer, ptr);
     AL_TEST_EQ(buf.end, buffer + BUFFER_SIZE, ptr);
-    AL_TEST_EQ(al_atomic_load(void)(&buf.read, AL_ATOMIC_RELAXED), buffer, ptr);
-    AL_TEST_EQ(al_atomic_load(void)(&buf.write, AL_ATOMIC_RELAXED), buffer, ptr);
+    AL_TEST_EQ(atomic_load(void)(&buf.read, AL_ATOMIC_RELAXED), buffer, ptr);
+    AL_TEST_EQ(atomic_load(void)(&buf.write, AL_ATOMIC_RELAXED), buffer, ptr);
 
     AL_TEST_END();
 }
@@ -112,7 +112,7 @@ static bool ring_buffer_test_read_and_write(void)
     AL_TEST_EQ(al_ring_buffer_write(&buf, half_buffer, sizeof(half_buffer)), sizeof(half_buffer), ptrdiff_t);
     AL_TEST_EQ(al_ring_buffer_occupied(&buf), BUFFER_SIZE - data_size, ptrdiff_t);
     // Test that we wrapped.
-    AL_TEST_LT(al_atomic_load(void)(&buf.write, AL_ATOMIC_RELAXED), al_atomic_load(void)(&buf.read, AL_ATOMIC_RELAXED), ptr);
+    AL_TEST_LT(atomic_load(void)(&buf.write, AL_ATOMIC_RELAXED), atomic_load(void)(&buf.read, AL_ATOMIC_RELAXED), ptr);
 
     ptrdiff_t space = al_ring_buffer_space(&buf);
     // Maximum space is BUFFER_SIZE - 1.