Use separate macros for atomics that don't take a memory order

6 files changed, 60 insertions, 57 deletions

diff --git a/OpenAL32/alAuxEffectSlot.c b/OpenAL32/alAuxEffectSlot.c
index 4f1601ed..a7bc0f32 100644
--- a/OpenAL32/alAuxEffectSlot.c
+++ b/OpenAL32/alAuxEffectSlot.c
@@ -114,11 +114,11 @@ AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslo
     }
     if(last != NULL)
     {
-        ALeffectslot *root = ATOMIC_LOAD(&context->ActiveAuxSlotList);
+        ALeffectslot *root = ATOMIC_LOAD_SEQ(&context->ActiveAuxSlotList);
         do {
             ATOMIC_STORE(&last->next, root, almemory_order_relaxed);
-        } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALeffectslot*, &context->ActiveAuxSlotList,
-                                              &root, first));
+        } while(!ATOMIC_COMPARE_EXCHANGE_WEAK_SEQ(ALeffectslot*, &context->ActiveAuxSlotList,
+                                                  &root, first));
     }
 
 done:
@@ -436,14 +436,14 @@ static void RemoveEffectSlotList(ALCcontext *context, ALeffectslot *slot)
     ALeffectslot *root, *next;
 
     root = slot;
-    next = ATOMIC_LOAD(&slot->next);
-    if(!ATOMIC_COMPARE_EXCHANGE_STRONG(ALeffectslot*, &context->ActiveAuxSlotList, &root, next))
+    next = ATOMIC_LOAD_SEQ(&slot->next);
+    if(!ATOMIC_COMPARE_EXCHANGE_STRONG_SEQ(ALeffectslot*, &context->ActiveAuxSlotList, &root, next))
     {
         ALeffectslot *cur;
         do {
             cur = root;
             root = slot;
-        } while(!ATOMIC_COMPARE_EXCHANGE_STRONG(ALeffectslot*, &cur->next, &root, next));
+        } while(!ATOMIC_COMPARE_EXCHANGE_STRONG_SEQ(ALeffectslot*, &cur->next, &root, next));
     }
     /* Wait for any mix that may be using these effect slots to finish. */
     while((ReadRef(&device->MixCount)&1) != 0)
@@ -527,7 +527,7 @@ ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *e
         EffectSlot->Effect.Props = effect->Props;
 
     /* Remove state references from old effect slot property updates. */
-    props = ATOMIC_LOAD(&EffectSlot->FreeList);
+    props = ATOMIC_LOAD_SEQ(&EffectSlot->FreeList);
     while(props)
     {
         State = ATOMIC_EXCHANGE(ALeffectState*, &props->State, NULL, almemory_order_relaxed);
@@ -605,7 +605,7 @@ void DeinitEffectSlot(ALeffectslot *slot)
     ALeffectState *state;
     size_t count = 0;
 
-    props = ATOMIC_LOAD(&slot->Update);
+    props = ATOMIC_LOAD_SEQ(&slot->Update);
     if(props)
     {
         state = ATOMIC_LOAD(&props->State, almemory_order_relaxed);
@@ -671,10 +671,10 @@ void UpdateEffectSlotProps(ALeffectslot *slot)
         /* If there was an unused update container, put it back in the
          * freelist.
          */
-        struct ALeffectslotProps *first = ATOMIC_LOAD(&slot->FreeList);
+        struct ALeffectslotProps *first = ATOMIC_LOAD_SEQ(&slot->FreeList);
         do {
             ATOMIC_STORE(&props->next, first, almemory_order_relaxed);
-        } while(ATOMIC_COMPARE_EXCHANGE_WEAK(struct ALeffectslotProps*,
+        } while(ATOMIC_COMPARE_EXCHANGE_WEAK_SEQ(struct ALeffectslotProps*,
                 &slot->FreeList, &first, props) == 0);
     }
 
@@ -687,7 +687,7 @@ void UpdateAllEffectSlotProps(ALCcontext *context)
     ALeffectslot *slot;
 
     LockEffectSlotsRead(context);
-    slot = ATOMIC_LOAD(&context->ActiveAuxSlotList);
+    slot = ATOMIC_LOAD_SEQ(&context->ActiveAuxSlotList);
     while(slot)
     {
         if(slot->NeedsUpdate)
diff --git a/OpenAL32/alBuffer.c b/OpenAL32/alBuffer.c
index 193cfeaa..24470d64 100644
--- a/OpenAL32/alBuffer.c
+++ b/OpenAL32/alBuffer.c
@@ -161,7 +161,7 @@ AL_API ALvoid AL_APIENTRY alBufferData(ALuint buffer, ALenum format, const ALvoi
     if(DecomposeUserFormat(format, &srcchannels, &srctype) == AL_FALSE)
         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 
-    align = ATOMIC_LOAD(&albuf->UnpackAlign);
+    align = ATOMIC_LOAD_SEQ(&albuf->UnpackAlign);
     if(SanitizeAlignment(srctype, &align) == AL_FALSE)
         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
     switch(srctype)
@@ -311,7 +311,7 @@ AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer, ALenum format, cons
         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 
     WriteLock(&albuf->lock);
-    align = ATOMIC_LOAD(&albuf->UnpackAlign);
+    align = ATOMIC_LOAD_SEQ(&albuf->UnpackAlign);
     if(SanitizeAlignment(srctype, &align) == AL_FALSE)
     {
         WriteUnlock(&albuf->lock);
@@ -390,7 +390,7 @@ AL_API void AL_APIENTRY alBufferSamplesSOFT(ALuint buffer,
     if(IsValidType(type) == AL_FALSE || IsValidChannels(channels) == AL_FALSE)
         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 
-    align = ATOMIC_LOAD(&albuf->UnpackAlign);
+    align = ATOMIC_LOAD_SEQ(&albuf->UnpackAlign);
     if(SanitizeAlignment(type, &align) == AL_FALSE)
         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
     if((samples%align) != 0)
@@ -428,7 +428,7 @@ AL_API void AL_APIENTRY alBufferSubSamplesSOFT(ALuint buffer,
         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 
     WriteLock(&albuf->lock);
-    align = ATOMIC_LOAD(&albuf->UnpackAlign);
+    align = ATOMIC_LOAD_SEQ(&albuf->UnpackAlign);
     if(SanitizeAlignment(type, &align) == AL_FALSE)
     {
         WriteUnlock(&albuf->lock);
@@ -483,7 +483,7 @@ AL_API void AL_APIENTRY alGetBufferSamplesSOFT(ALuint buffer,
         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 
     ReadLock(&albuf->lock);
-    align = ATOMIC_LOAD(&albuf->PackAlign);
+    align = ATOMIC_LOAD_SEQ(&albuf->PackAlign);
     if(SanitizeAlignment(type, &align) == AL_FALSE)
     {
         ReadUnlock(&albuf->lock);
@@ -630,13 +630,13 @@ AL_API void AL_APIENTRY alBufferi(ALuint buffer, ALenum param, ALint value)
     case AL_UNPACK_BLOCK_ALIGNMENT_SOFT:
         if(!(value >= 0))
             SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
-        ATOMIC_STORE(&albuf->UnpackAlign, value);
+        ATOMIC_STORE_SEQ(&albuf->UnpackAlign, value);
         break;
 
     case AL_PACK_BLOCK_ALIGNMENT_SOFT:
         if(!(value >= 0))
             SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
-        ATOMIC_STORE(&albuf->PackAlign, value);
+        ATOMIC_STORE_SEQ(&albuf->PackAlign, value);
         break;
 
     default:
@@ -878,11 +878,11 @@ AL_API ALvoid AL_APIENTRY alGetBufferi(ALuint buffer, ALenum param, ALint *value
         break;
 
     case AL_UNPACK_BLOCK_ALIGNMENT_SOFT:
-        *value = ATOMIC_LOAD(&albuf->UnpackAlign);
+        *value = ATOMIC_LOAD_SEQ(&albuf->UnpackAlign);
         break;
 
     case AL_PACK_BLOCK_ALIGNMENT_SOFT:
-        *value = ATOMIC_LOAD(&albuf->PackAlign);
+        *value = ATOMIC_LOAD_SEQ(&albuf->PackAlign);
         break;
 
     default:
diff --git a/OpenAL32/alError.c b/OpenAL32/alError.c
index b38d8dfe..6b7684ce 100644
--- a/OpenAL32/alError.c
+++ b/OpenAL32/alError.c
@@ -46,7 +46,7 @@ ALvoid alSetError(ALCcontext *Context, ALenum errorCode)
         raise(SIGTRAP);
 #endif
     }
-    ATOMIC_COMPARE_EXCHANGE_STRONG(ALenum, &Context->LastError, &curerr, errorCode);
+    ATOMIC_COMPARE_EXCHANGE_STRONG_SEQ(ALenum, &Context->LastError, &curerr, errorCode);
 }
 
 AL_API ALenum AL_APIENTRY alGetError(void)
@@ -69,7 +69,7 @@ AL_API ALenum AL_APIENTRY alGetError(void)
         return AL_INVALID_OPERATION;
     }
 
-    errorCode = ATOMIC_EXCHANGE(ALenum, &Context->LastError, AL_NO_ERROR);
+    errorCode = ATOMIC_EXCHANGE_SEQ(ALenum, &Context->LastError, AL_NO_ERROR);
 
     ALCcontext_DecRef(Context);
 
diff --git a/OpenAL32/alListener.c b/OpenAL32/alListener.c
index 4e99f24e..f05c20d1 100644
--- a/OpenAL32/alListener.c
+++ b/OpenAL32/alListener.c
@@ -506,10 +506,10 @@ void UpdateListenerProps(ALCcontext *context)
         /* If there was an unused update container, put it back in the
          * freelist.
          */
-        struct ALlistenerProps *first = ATOMIC_LOAD(&listener->FreeList);
+        struct ALlistenerProps *first = ATOMIC_LOAD_SEQ(&listener->FreeList);
         do {
             ATOMIC_STORE(&props->next, first, almemory_order_relaxed);
-        } while(ATOMIC_COMPARE_EXCHANGE_WEAK(struct ALlistenerProps*,
+        } while(ATOMIC_COMPARE_EXCHANGE_WEAK_SEQ(struct ALlistenerProps*,
                 &listener->FreeList, &first, props) == 0);
     }
 }
diff --git a/OpenAL32/alSource.c b/OpenAL32/alSource.c
index 81cd44cd..9f60c545 100644
--- a/OpenAL32/alSource.c
+++ b/OpenAL32/alSource.c
@@ -658,7 +658,7 @@ static ALboolean SetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp p
             CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
 
             WriteLock(&Source->queue_lock);
-            ATOMIC_STORE(&Source->looping, *values);
+            ATOMIC_STORE_SEQ(&Source->looping, *values);
             WriteUnlock(&Source->queue_lock);
             return AL_TRUE;
 
@@ -700,8 +700,8 @@ static ALboolean SetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp p
                 Source->SourceType = AL_UNDETERMINED;
                 newlist = NULL;
             }
-            oldlist = ATOMIC_EXCHANGE(ALbufferlistitem*, &Source->queue, newlist);
-            ATOMIC_STORE(&Source->current_buffer, newlist);
+            oldlist = ATOMIC_EXCHANGE_SEQ(ALbufferlistitem*, &Source->queue, newlist);
+            ATOMIC_STORE_SEQ(&Source->current_buffer, newlist);
             WriteUnlock(&Source->queue_lock);
             UnlockBuffersRead(device);
 
@@ -1097,7 +1097,7 @@ static ALboolean GetSourcedv(ALsource *Source, ALCcontext *Context, SourceProp p
 
         case AL_SEC_LENGTH_SOFT:
             ReadLock(&Source->queue_lock);
-            if(!(BufferList=ATOMIC_LOAD(&Source->queue)))
+            if(!(BufferList=ATOMIC_LOAD_SEQ(&Source->queue)))
                 *values = 0;
             else
             {
@@ -1214,13 +1214,14 @@ static ALboolean GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp p
             return AL_TRUE;
 
         case AL_LOOPING:
-            *values = ATOMIC_LOAD(&Source->looping);
+            *values = ATOMIC_LOAD_SEQ(&Source->looping);
             return AL_TRUE;
 
         case AL_BUFFER:
             ReadLock(&Source->queue_lock);
-            BufferList = (Source->SourceType == AL_STATIC) ? ATOMIC_LOAD(&Source->queue) :
-                                                             ATOMIC_LOAD(&Source->current_buffer);
+            BufferList = (Source->SourceType == AL_STATIC) ?
+                         ATOMIC_LOAD_SEQ(&Source->queue) :
+                         ATOMIC_LOAD_SEQ(&Source->current_buffer);
             *values = (BufferList && BufferList->buffer) ? BufferList->buffer->id : 0;
             ReadUnlock(&Source->queue_lock);
             return AL_TRUE;
@@ -1231,7 +1232,7 @@ static ALboolean GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp p
 
         case AL_BYTE_LENGTH_SOFT:
             ReadLock(&Source->queue_lock);
-            if(!(BufferList=ATOMIC_LOAD(&Source->queue)))
+            if(!(BufferList=ATOMIC_LOAD_SEQ(&Source->queue)))
                 *values = 0;
             else
             {
@@ -1270,7 +1271,7 @@ static ALboolean GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp p
 
         case AL_SAMPLE_LENGTH_SOFT:
             ReadLock(&Source->queue_lock);
-            if(!(BufferList=ATOMIC_LOAD(&Source->queue)))
+            if(!(BufferList=ATOMIC_LOAD_SEQ(&Source->queue)))
                 *values = 0;
             else
             {
@@ -1286,7 +1287,7 @@ static ALboolean GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp p
 
         case AL_BUFFERS_QUEUED:
             ReadLock(&Source->queue_lock);
-            if(!(BufferList=ATOMIC_LOAD(&Source->queue)))
+            if(!(BufferList=ATOMIC_LOAD_SEQ(&Source->queue)))
                 *values = 0;
             else
             {
@@ -1301,7 +1302,7 @@ static ALboolean GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp p
 
         case AL_BUFFERS_PROCESSED:
             ReadLock(&Source->queue_lock);
-            if(ATOMIC_LOAD(&Source->looping) || Source->SourceType != AL_STREAMING)
+            if(ATOMIC_LOAD_SEQ(&Source->looping) || Source->SourceType != AL_STREAMING)
             {
                 /* Buffers on a looping source are in a perpetual state of
                  * PENDING, so don't report any as PROCESSED */
@@ -1309,8 +1310,8 @@ static ALboolean GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp p
             }
             else
             {
-                const ALbufferlistitem *BufferList = ATOMIC_LOAD(&Source->queue);
-                const ALbufferlistitem *Current = ATOMIC_LOAD(&Source->current_buffer);
+                const ALbufferlistitem *BufferList = ATOMIC_LOAD_SEQ(&Source->queue);
+                const ALbufferlistitem *Current = ATOMIC_LOAD_SEQ(&Source->current_buffer);
                 ALsizei played = 0;
                 while(BufferList && BufferList != Current)
                 {
@@ -2499,7 +2500,7 @@ AL_API ALvoid AL_APIENTRY alSourceQueueBuffers(ALuint src, ALsizei nb, const ALu
     }
 
     /* Check for a valid Buffer, for its frequency and format */
-    BufferList = ATOMIC_LOAD(&source->queue);
+    BufferList = ATOMIC_LOAD_SEQ(&source->queue);
     while(BufferList)
     {
         if(BufferList->buffer)
@@ -2588,7 +2589,8 @@ AL_API ALvoid AL_APIENTRY alSourceQueueBuffers(ALuint src, ALsizei nb, const ALu
     source->SourceType = AL_STREAMING;
 
     BufferList = NULL;
-    if(!ATOMIC_COMPARE_EXCHANGE_STRONG(ALbufferlistitem*, &source->queue, &BufferList, BufferListStart))
+    if(!ATOMIC_COMPARE_EXCHANGE_STRONG_SEQ(ALbufferlistitem*, &source->queue,
+                                           &BufferList, BufferListStart))
     {
         /* Queue head is not NULL, append to the end of the queue */
         while(BufferList->next != NULL)
@@ -2599,7 +2601,8 @@ AL_API ALvoid AL_APIENTRY alSourceQueueBuffers(ALuint src, ALsizei nb, const ALu
      * buffers.
      */
     BufferList = NULL;
-    ATOMIC_COMPARE_EXCHANGE_STRONG(ALbufferlistitem*, &source->current_buffer, &BufferList, BufferListStart);
+    ATOMIC_COMPARE_EXCHANGE_STRONG_SEQ(ALbufferlistitem*, &source->current_buffer,
+                                       &BufferList, BufferListStart);
     WriteUnlock(&source->queue_lock);
 
 done:
@@ -2630,7 +2633,7 @@ AL_API ALvoid AL_APIENTRY alSourceUnqueueBuffers(ALuint src, ALsizei nb, ALuint
         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 
     WriteLock(&source->queue_lock);
-    if(ATOMIC_LOAD(&source->looping) || source->SourceType != AL_STREAMING)
+    if(ATOMIC_LOAD_SEQ(&source->looping) || source->SourceType != AL_STREAMING)
     {
         WriteUnlock(&source->queue_lock);
         /* Trying to unqueue buffers on a looping or non-streaming source. */
@@ -2638,8 +2641,8 @@ AL_API ALvoid AL_APIENTRY alSourceUnqueueBuffers(ALuint src, ALsizei nb, ALuint
     }
 
     /* Find the new buffer queue head */
-    OldTail = ATOMIC_LOAD(&source->queue);
-    Current = ATOMIC_LOAD(&source->current_buffer);
+    OldTail = ATOMIC_LOAD_SEQ(&source->queue);
+    Current = ATOMIC_LOAD_SEQ(&source->current_buffer);
     if(OldTail != Current)
     {
         for(i = 1;i < nb;i++)
@@ -2657,7 +2660,7 @@ AL_API ALvoid AL_APIENTRY alSourceUnqueueBuffers(ALuint src, ALsizei nb, ALuint
     }
 
     /* Swap it, and cut the new head from the old. */
-    OldHead = ATOMIC_EXCHANGE(ALbufferlistitem*, &source->queue, OldTail->next);
+    OldHead = ATOMIC_EXCHANGE_SEQ(ALbufferlistitem*, &source->queue, OldTail->next);
     if(OldTail->next)
     {
         ALCdevice *device = context->Device;
@@ -2788,7 +2791,7 @@ static void DeinitSource(ALsource *source)
     size_t count = 0;
     size_t i;
 
-    props = ATOMIC_LOAD(&source->Update);
+    props = ATOMIC_LOAD_SEQ(&source->Update);
     if(props) al_free(props);
 
     props = ATOMIC_LOAD(&source->FreeList, almemory_order_relaxed);
@@ -2806,7 +2809,7 @@ static void DeinitSource(ALsource *source)
     if(count > 3)
         WARN("Freed "SZFMT" Source property objects\n", count);
 
-    BufferList = ATOMIC_EXCHANGE(ALbufferlistitem*, &source->queue, NULL);
+    BufferList = ATOMIC_EXCHANGE_SEQ(ALbufferlistitem*, &source->queue, NULL);
     while(BufferList != NULL)
     {
         ALbufferlistitem *next = BufferList->next;
@@ -2910,7 +2913,7 @@ static void UpdateSourceProps(ALsource *source, ALuint num_sends)
         /* If there was an unused update container, put it back in the
          * freelist.
          */
-        struct ALsourceProps *first = ATOMIC_LOAD(&source->FreeList);
+        struct ALsourceProps *first = ATOMIC_LOAD_SEQ(&source->FreeList);
         do {
             ATOMIC_STORE(&props->next, first, almemory_order_relaxed);
         } while(ATOMIC_COMPARE_EXCHANGE_WEAK(struct ALsourceProps*,
@@ -2956,7 +2959,7 @@ ALvoid SetSourceState(ALsource *Source, ALCcontext *Context, ALenum state)
 
         /* Check that there is a queue containing at least one valid, non zero
          * length Buffer. */
-        BufferList = ATOMIC_LOAD(&Source->queue);
+        BufferList = ATOMIC_LOAD_SEQ(&Source->queue);
         while(BufferList)
         {
             ALbuffer *buffer;
@@ -3052,7 +3055,7 @@ ALvoid SetSourceState(ALsource *Source, ALCcontext *Context, ALenum state)
         if(Source->state != AL_INITIAL)
         {
             Source->state = AL_STOPPED;
-            ATOMIC_STORE(&Source->current_buffer, NULL);
+            ATOMIC_STORE_SEQ(&Source->current_buffer, NULL);
         }
         Source->OffsetType = AL_NONE;
         Source->Offset = 0.0;
@@ -3062,10 +3065,10 @@ ALvoid SetSourceState(ALsource *Source, ALCcontext *Context, ALenum state)
         if(Source->state != AL_INITIAL)
         {
             Source->state = AL_INITIAL;
-            ATOMIC_STORE(&Source->current_buffer, ATOMIC_LOAD(&Source->queue),
+            ATOMIC_STORE(&Source->current_buffer, ATOMIC_LOAD_SEQ(&Source->queue),
                          almemory_order_relaxed);
             ATOMIC_STORE(&Source->position, 0, almemory_order_relaxed);
-            ATOMIC_STORE(&Source->position_fraction, 0);
+            ATOMIC_STORE_SEQ(&Source->position_fraction, 0);
         }
         Source->OffsetType = AL_NONE;
         Source->Offset = 0.0;
@@ -3304,7 +3307,7 @@ ALboolean ApplyOffset(ALsource *Source)
         return AL_FALSE;
 
     totalBufferLen = 0;
-    BufferList = ATOMIC_LOAD(&Source->queue);
+    BufferList = ATOMIC_LOAD_SEQ(&Source->queue);
     while(BufferList && totalBufferLen <= offset)
     {
         Buffer = BufferList->buffer;
@@ -3343,7 +3346,7 @@ static ALboolean GetSampleOffset(ALsource *Source, ALuint *offset, ALuint *frac)
     ALdouble dbloff, dblfrac;
 
     /* Find the first valid Buffer in the Queue */
-    BufferList = ATOMIC_LOAD(&Source->queue);
+    BufferList = ATOMIC_LOAD_SEQ(&Source->queue);
     while(BufferList)
     {
         if(BufferList->buffer)
diff --git a/OpenAL32/alThunk.c b/OpenAL32/alThunk.c
index 72fc0dcb..d3892c97 100644
--- a/OpenAL32/alThunk.c
+++ b/OpenAL32/alThunk.c
@@ -54,7 +54,7 @@ ALenum NewThunkEntry(ALuint *index)
     ReadLock(&ThunkLock);
     for(i = 0;i < ThunkArraySize;i++)
     {
-        if(ATOMIC_EXCHANGE(ALenum, &ThunkArray[i], AL_TRUE) == AL_FALSE)
+        if(ATOMIC_EXCHANGE(ALenum, &ThunkArray[i], AL_TRUE, almemory_order_acq_rel) == AL_FALSE)
         {
             ReadUnlock(&ThunkLock);
             *index = i+1;
@@ -69,7 +69,7 @@ ALenum NewThunkEntry(ALuint *index)
      */
     for(;i < ThunkArraySize;i++)
     {
-        if(ATOMIC_EXCHANGE(ALenum, &ThunkArray[i], AL_TRUE) == AL_FALSE)
+        if(ATOMIC_EXCHANGE(ALenum, &ThunkArray[i], AL_TRUE, almemory_order_acq_rel) == AL_FALSE)
         {
             WriteUnlock(&ThunkLock);
             *index = i+1;
@@ -89,7 +89,7 @@ ALenum NewThunkEntry(ALuint *index)
     ThunkArray = NewList;
     ThunkArraySize *= 2;
 
-    ATOMIC_STORE(&ThunkArray[i], AL_TRUE);
+    ATOMIC_STORE_SEQ(&ThunkArray[i], AL_TRUE);
     WriteUnlock(&ThunkLock);
 
     *index = i+1;
@@ -100,6 +100,6 @@ void FreeThunkEntry(ALuint index)
 {
     ReadLock(&ThunkLock);
     if(index > 0 && index <= ThunkArraySize)
-        ATOMIC_STORE(&ThunkArray[index-1], AL_FALSE);
+        ATOMIC_STORE_SEQ(&ThunkArray[index-1], AL_FALSE);
     ReadUnlock(&ThunkLock);
 }