[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[dotgnu-pnet-commits] [SCM] DotGNU Portable.NET engine, compilers and to
|
From: |
Klaus Treichel |
|
Subject: |
[dotgnu-pnet-commits] [SCM] DotGNU Portable.NET engine, compilers and tools (pnet) branch, master, updated. f325522c597e4e178037606c03c2b7c9a66ea637 |
|
Date: |
Wed, 28 Oct 2009 10:36:16 +0000 |
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "DotGNU Portable.NET engine, compilers and tools (pnet)".
The branch, master has been updated
via f325522c597e4e178037606c03c2b7c9a66ea637 (commit)
from 86384a46716a3defd4866339df1423fef667e9ee (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
http://git.savannah.gnu.org/cgit/pnet.git/commit/?id=f325522c597e4e178037606c03c2b7c9a66ea637
commit f325522c597e4e178037606c03c2b7c9a66ea637
Author: Klaus Treichel <address@hidden>
Date: Wed Oct 28 11:35:47 2009 +0100
Extend the interlocked functions to support multiple native types.
diff --git a/ChangeLog b/ChangeLog
index de47ac1..ec3f023 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,24 @@
+2009-10-28 Klaus Treichel <address@hidden>
+
+ * support/interlocked.h, support/interlocked_any.h,
+ support/interlocked_arm.h, support/interlocked_x86.h: Extend interlocked
+ functions to support multiple native types.
+
+ * support/monitor.c: Adjust calls to interlocked functions to the
+ new extended name scheme with type specifier.
+
+ * test/test_thread.c: likewise
+
+ * engine/cvm_call.c: likewise
+
+ * engine/lib_defs.h: likewise
+
+ * engine/lib_object.c: likewise
+
+ * engine/thread.c: likewise
+
+ * engine/lib_thread.c: Use the new interlocked functions where possible.
+
2009-10-11 Klaus Treichel <address@hidden>
* support/Makefile.am: add interlocked_arm.h and interlocked_ppc.h to
diff --git a/engine/cvm_call.c b/engine/cvm_call.c
index 9e76b83..e5a5375 100644
--- a/engine/cvm_call.c
+++ b/engine/cvm_call.c
@@ -103,8 +103,8 @@ ILCallFrame *_ILAllocCallFrame(ILExecThread *thread)
{ \
if (_ILExecThreadSelfAborting(thread) == 0) \
{ \
-
ILInterlockedAnd(&(thread->managedSafePointFlags), \
-
~_IL_MANAGED_SAFEPOINT_THREAD_ABORT); \
+
ILInterlockedAndU4(&(thread->managedSafePointFlags), \
+
~_IL_MANAGED_SAFEPOINT_THREAD_ABORT); \
stacktop[0].ptrValue = thread->thrownException;
\
thread->thrownException = 0; \
stacktop += 1; \
@@ -113,8 +113,8 @@ ILCallFrame *_ILAllocCallFrame(ILExecThread *thread)
} \
else if (thread->managedSafePointFlags &
_IL_MANAGED_SAFEPOINT_THREAD_SUSPEND) \
{ \
- ILInterlockedAnd(&(thread->managedSafePointFlags), \
-
~_IL_MANAGED_SAFEPOINT_THREAD_SUSPEND); \
+ ILInterlockedAndU4(&(thread->managedSafePointFlags), \
+
~_IL_MANAGED_SAFEPOINT_THREAD_SUSPEND); \
if (ILThreadGetState(thread->supportThread) &
IL_TS_SUSPEND_REQUESTED) \
{ \
_ILExecThreadSuspendThread(thread,
thread->supportThread); \
@@ -2122,7 +2122,7 @@ VMBREAK(COP_PREFIX_PACK_VARARGS);
VMCASE(COP_PREFIX_PROFILE_COUNT):
{
BEGIN_NATIVE_CALL();
- ILInterlockedIncrement((ILInt32 *)(&method->count));
+ ILInterlockedIncrementI4((ILInt32 *)(&method->count));
END_NATIVE_CALL();
MODIFY_PC_AND_STACK(CVMP_LEN_NONE,0);
}
diff --git a/engine/lib_defs.h b/engine/lib_defs.h
index 5d27662..d2ba472 100644
--- a/engine/lib_defs.h
+++ b/engine/lib_defs.h
@@ -146,7 +146,7 @@ extern "C" {
(&(GetObjectLockWord(thread, obj)))
#define CompareAndExchangeObjectLockWord(thread, obj, value, comparand)
\
- (ILLockWord)((ILInterlockedCompareAndExchangePointers \
+ (ILLockWord)((ILInterlockedCompareAndExchangeP_Full \
((void **)GetObjectLockWordPtr(thread, obj), (void
*)value, (void *)comparand)))
#endif
diff --git a/engine/lib_object.c b/engine/lib_object.c
index 99f4459..704a9df 100644
--- a/engine/lib_object.c
+++ b/engine/lib_object.c
@@ -171,7 +171,7 @@ ILObject *_ILGetClrType(ILExecThread *thread, ILClass
*classInfo)
for each class is used.
If there was one extra object created it will be
collected by
the garbage collector */
- ILInterlockedCompareAndExchangePointers((void
**)&(classPrivate->clrType), obj, 0);
+ ILInterlockedCompareAndExchangeP((void
**)&(classPrivate->clrType), obj, 0);
}
}
diff --git a/engine/lib_thread.c b/engine/lib_thread.c
index c1eba0a..0105b4d 100644
--- a/engine/lib_thread.c
+++ b/engine/lib_thread.c
@@ -63,7 +63,7 @@ ILInt32 _IL_Interlocked_CompareExchange_Riii
ILInt32 value,
ILInt32 comparand)
{
- return ILInterlockedCompareAndExchange(location1, value, comparand);
+ return ILInterlockedCompareAndExchangeI4_Full(location1, value,
comparand);
}
/*
@@ -71,7 +71,7 @@ ILInt32 _IL_Interlocked_CompareExchange_Riii
*/
ILInt32 _IL_Interlocked_Increment_Ri(ILExecThread *thread, ILInt32 *location)
{
- return ILInterlockedIncrement(location);
+ return ILInterlockedIncrementI4_Full(location);
}
@@ -80,7 +80,7 @@ ILInt32 _IL_Interlocked_Increment_Ri(ILExecThread *thread,
ILInt32 *location)
*/
ILInt32 _IL_Interlocked_Decrement_Ri(ILExecThread *thread, ILInt32 *location)
{
- return ILInterlockedDecrement(location);
+ return ILInterlockedDecrementI4_Full(location);
}
/*
@@ -89,7 +89,7 @@ ILInt32 _IL_Interlocked_Decrement_Ri(ILExecThread *thread,
ILInt32 *location)
ILInt32 _IL_Interlocked_Exchange_Rii(ILExecThread *thread,
ILInt32 *location, ILInt32 value)
{
- return ILInterlockedExchange(location, value);
+ return ILInterlockedExchangeI4_Full(location, value);
}
/*************************************/
@@ -101,13 +101,7 @@ ILInt32 _IL_Interlocked_Exchange_Rii(ILExecThread *thread,
*/
ILInt64 _IL_Interlocked_Increment_Rl(ILExecThread *thread, ILInt64 *location)
{
- ILInt64 value;
- ILThreadAtomicStart();
- ILMemCpy(&value, location, sizeof(ILInt64));
- ++value;
- ILMemCpy(location, &value, sizeof(ILInt64));
- ILThreadAtomicEnd();
- return value;
+ return ILInterlockedIncrementI8_Full(location);
}
/*
@@ -115,13 +109,7 @@ ILInt64 _IL_Interlocked_Increment_Rl(ILExecThread *thread,
ILInt64 *location)
*/
ILInt64 _IL_Interlocked_Decrement_Rl(ILExecThread *thread, ILInt64 *location)
{
- ILInt64 value;
- ILThreadAtomicStart();
- ILMemCpy(&value, location, sizeof(ILInt64));
- --value;
- ILMemCpy(location, &value, sizeof(ILInt64));
- ILThreadAtomicEnd();
- return value;
+ return ILInterlockedDecrementI8_Full(location);
}
/*************************************/
@@ -134,21 +122,7 @@ ILInt64 _IL_Interlocked_Decrement_Rl(ILExecThread *thread,
ILInt64 *location)
ILFloat _IL_Interlocked_Exchange_Rff(ILExecThread *thread,
ILFloat
*location, ILFloat value)
{
-#if (SIZEOF_FLOAT == 4)
- ILInt32 retval;
-
- /* memcpy to get rid of type-punned pointer warning */
- retval = ILInterlockedExchange((ILInt32 *)location, *(ILInt32 *)(void
*)&value);
-
- return *(ILFloat *)(void *)&retval;
-#else
- ILFloat orig;
- ILThreadAtomicStart();
- orig = *location;
- *location = value;
- ILThreadAtomicEnd();
- return orig;
-#endif
+ return ILInterlockedExchangeR4_Full(location, value);
}
/*
@@ -158,23 +132,7 @@ ILFloat _IL_Interlocked_Exchange_Rff(ILExecThread *thread,
ILFloat _IL_Interlocked_CompareExchange_Rfff(ILExecThread *thread, ILFloat
*location1,
ILFloat value, ILFloat
comparand)
{
-#if (SIZEOF_FLOAT == 4)
- ILInt32 retval;
-
- retval = ILInterlockedCompareAndExchange((ILInt32 *)location1,
*((ILInt32 *)(void *)&value), *((ILInt32 *)(void *)&comparand));
-
- return *(ILFloat *)(void *)&retval;
-#else
- ILFloat orig;
- ILThreadAtomicStart();
- if((orig = *location1) == comparand)
- {
- *location1 = value;
- }
- ILThreadAtomicEnd();
-
- return orig;
-#endif
+ return ILInterlockedCompareAndExchangeR4_Full(location1, value,
comparand);
}
/***************************************/
@@ -187,7 +145,8 @@ ILFloat _IL_Interlocked_CompareExchange_Rfff(ILExecThread
*thread, ILFloat *loca
ILObject *_IL_Interlocked_Exchange_RObjectObject
(ILExecThread *thread, ILObject **location, ILObject *value)
{
- return ILInterlockedExchangePointers((void **)location, (void *)value);
+ return (ILObject *)ILInterlockedExchangeP_Full((void **)location,
+
(void *)value);
}
/*
@@ -200,7 +159,7 @@ ILObject
*_IL_Interlocked_CompareExchange_RObjectObjectObject
ILObject *value,
ILObject *comparand)
{
- return (ILObject *)ILInterlockedCompareAndExchangePointers((void
**)location1, (void *)value, (void *)comparand);
+ return (ILObject *)ILInterlockedCompareAndExchangeP_Full((void
**)location1, (void *)value, (void *)comparand);
}
/*
@@ -432,7 +391,7 @@ ILBool _IL_Thread_InternalJoin(ILExecThread *thread,
ILObject *_this,
*/
void _IL_Thread_MemoryBarrier(ILExecThread *thread)
{
- ILThreadMemoryBarrier();
+ ILInterlockedMemoryBarrier();
}
/*
@@ -452,8 +411,8 @@ void _IL_Thread_ResetAbort(ILExecThread *thread)
if (ILThreadAbortReset())
{
- ILInterlockedAnd(&(thread->managedSafePointFlags),
-
~_IL_MANAGED_SAFEPOINT_THREAD_ABORT);
+ ILInterlockedAndU4(&(thread->managedSafePointFlags),
+
~_IL_MANAGED_SAFEPOINT_THREAD_ABORT);
thread->aborting = 0;
#ifdef IL_USE_CVM
thread->abortHandlerEndPC = 0;
@@ -648,9 +607,7 @@ ILBool _IL_Thread_CanStartThreads(ILExecThread *_thread)
*/
ILInt8 _IL_Thread_VolatileRead_Rb(ILExecThread *thread, ILInt8 *address)
{
- ILInterlockedMemoryBarrier();
-
- return *((volatile ILInt8 *)address);
+ return ILInterlockedLoadI1(address);
}
/*
@@ -658,9 +615,7 @@ ILInt8 _IL_Thread_VolatileRead_Rb(ILExecThread *thread,
ILInt8 *address)
*/
ILUInt8 _IL_Thread_VolatileRead_RB(ILExecThread *thread, ILUInt8 *address)
{
- ILInterlockedMemoryBarrier();
-
- return *((volatile ILUInt8 *)address);
+ return ILInterlockedLoadU1(address);
}
/*
@@ -668,9 +623,7 @@ ILUInt8 _IL_Thread_VolatileRead_RB(ILExecThread *thread,
ILUInt8 *address)
*/
ILInt16 _IL_Thread_VolatileRead_Rs(ILExecThread *thread, ILInt16 *address)
{
- ILInterlockedMemoryBarrier();
-
- return *((volatile ILInt16 *)address);
+ return ILInterlockedLoadI2(address);
}
/*
@@ -678,9 +631,7 @@ ILInt16 _IL_Thread_VolatileRead_Rs(ILExecThread *thread,
ILInt16 *address)
*/
ILUInt16 _IL_Thread_VolatileRead_RS(ILExecThread *thread, ILUInt16 *address)
{
- ILInterlockedMemoryBarrier();
-
- return *((volatile ILUInt16 *)address);
+ return ILInterlockedLoadU2(address);
}
/*
@@ -688,9 +639,7 @@ ILUInt16 _IL_Thread_VolatileRead_RS(ILExecThread *thread,
ILUInt16 *address)
*/
ILInt32 _IL_Thread_VolatileRead_Ri(ILExecThread *thread, ILInt32 *address)
{
- ILInterlockedMemoryBarrier();
-
- return *((volatile ILInt32 *)address);
+ return ILInterlockedLoadI4(address);
}
/*
@@ -698,9 +647,7 @@ ILInt32 _IL_Thread_VolatileRead_Ri(ILExecThread *thread,
ILInt32 *address)
*/
ILUInt32 _IL_Thread_VolatileRead_RI(ILExecThread *thread, ILUInt32 *address)
{
- ILInterlockedMemoryBarrier();
-
- return *((volatile ILUInt32 *)address);
+ return ILInterlockedLoadU4(address);
}
/*
@@ -708,9 +655,7 @@ ILUInt32 _IL_Thread_VolatileRead_RI(ILExecThread *thread,
ILUInt32 *address)
*/
ILInt64 _IL_Thread_VolatileRead_Rl(ILExecThread *thread, ILInt64 *address)
{
- ILInterlockedMemoryBarrier();
-
- return *((volatile ILInt64 *)address);
+ return ILInterlockedLoadI8(address);
}
/*
@@ -718,9 +663,7 @@ ILInt64 _IL_Thread_VolatileRead_Rl(ILExecThread *thread,
ILInt64 *address)
*/
ILUInt64 _IL_Thread_VolatileRead_RL(ILExecThread *thread, ILUInt64 *address)
{
- ILInterlockedMemoryBarrier();
-
- return *((volatile ILUInt64 *)address);
+ return ILInterlockedLoadU8(address);
}
/*
@@ -729,9 +672,7 @@ ILUInt64 _IL_Thread_VolatileRead_RL(ILExecThread *thread,
ILUInt64 *address)
ILNativeInt _IL_Thread_VolatileRead_Rj(ILExecThread *thread,
ILNativeInt *address)
{
- ILInterlockedMemoryBarrier();
-
- return *((volatile ILNativeInt *)address);
+ return (ILNativeInt)ILInterlockedLoadP((void **)address);
}
/*
@@ -740,9 +681,7 @@ ILNativeInt _IL_Thread_VolatileRead_Rj(ILExecThread *thread,
ILNativeUInt _IL_Thread_VolatileRead_RJ(ILExecThread *thread,
ILNativeUInt *address)
{
- ILInterlockedMemoryBarrier();
-
- return *((volatile ILNativeUInt *)address);
+ return (ILNativeUInt)ILInterlockedLoadP((void **)address);
}
/*
@@ -750,9 +689,7 @@ ILNativeUInt _IL_Thread_VolatileRead_RJ(ILExecThread
*thread,
*/
ILFloat _IL_Thread_VolatileRead_Rf(ILExecThread *thread, ILFloat *address)
{
- ILInterlockedMemoryBarrier();
-
- return *((volatile ILFloat *)address);
+ return ILInterlockedLoadR4(address);
}
/*
@@ -760,9 +697,7 @@ ILFloat _IL_Thread_VolatileRead_Rf(ILExecThread *thread,
ILFloat *address)
*/
ILDouble _IL_Thread_VolatileRead_Rd(ILExecThread *thread, ILDouble *address)
{
- ILInterlockedMemoryBarrier();
-
- return *((volatile ILDouble *)address);
+ return ILInterlockedLoadR8(address);
}
/*
@@ -771,9 +706,7 @@ ILDouble _IL_Thread_VolatileRead_Rd(ILExecThread *thread,
ILDouble *address)
ILObject *_IL_Thread_VolatileRead_RObject(ILExecThread *thread,
ILObject **address)
{
- ILInterlockedMemoryBarrier();
-
- return (ILObject *)(*((ILObject volatile * volatile *)address));
+ return (ILObject *)ILInterlockedLoadP((void **)address);
}
/*
@@ -782,9 +715,7 @@ ILObject *_IL_Thread_VolatileRead_RObject(ILExecThread
*thread,
void _IL_Thread_VolatileWrite_Rbb(ILExecThread *thread,
ILInt8
*address, ILInt8 value)
{
- *((volatile ILInt8 *)address) = value;
-
- ILInterlockedMemoryBarrier();
+ ILInterlockedStoreI1_Acquire(address, value);
}
/*
@@ -793,9 +724,7 @@ void _IL_Thread_VolatileWrite_Rbb(ILExecThread *thread,
void _IL_Thread_VolatileWrite_RBB(ILExecThread *thread,
ILUInt8
*address, ILUInt8 value)
{
- *((volatile ILUInt8 *)address) = value;
-
- ILInterlockedMemoryBarrier();
+ ILInterlockedStoreU1_Acquire(address, value);
}
/*
@@ -804,9 +733,7 @@ void _IL_Thread_VolatileWrite_RBB(ILExecThread *thread,
void _IL_Thread_VolatileWrite_Rss(ILExecThread *thread,
ILInt16
*address, ILInt16 value)
{
- *((volatile ILInt16 *)address) = value;
-
- ILInterlockedMemoryBarrier();
+ ILInterlockedStoreI2_Acquire(address, value);
}
/*
@@ -815,9 +742,7 @@ void _IL_Thread_VolatileWrite_Rss(ILExecThread *thread,
void _IL_Thread_VolatileWrite_RSS(ILExecThread *thread,
ILUInt16
*address, ILUInt16 value)
{
- *((volatile ILUInt16 *)address) = value;
-
- ILInterlockedMemoryBarrier();
+ ILInterlockedStoreU2_Acquire(address, value);
}
/*
@@ -826,9 +751,7 @@ void _IL_Thread_VolatileWrite_RSS(ILExecThread *thread,
void _IL_Thread_VolatileWrite_Rii(ILExecThread *thread,
ILInt32
*address, ILInt32 value)
{
- *((volatile ILInt32 *)address) = value;
-
- ILInterlockedMemoryBarrier();
+ ILInterlockedStoreI4_Acquire(address, value);
}
/*
@@ -837,9 +760,7 @@ void _IL_Thread_VolatileWrite_Rii(ILExecThread *thread,
void _IL_Thread_VolatileWrite_RII(ILExecThread *thread,
ILUInt32
*address, ILUInt32 value)
{
- *((volatile ILUInt32 *)address) = value;
-
- ILInterlockedMemoryBarrier();
+ ILInterlockedStoreU4_Acquire(address, value);
}
/*
@@ -848,9 +769,7 @@ void _IL_Thread_VolatileWrite_RII(ILExecThread *thread,
void _IL_Thread_VolatileWrite_Rll(ILExecThread *thread,
ILInt64
*address, ILInt64 value)
{
- *((volatile ILInt64 *)address) = value;
-
- ILInterlockedMemoryBarrier();
+ ILInterlockedStoreI8_Acquire(address, value);
}
/*
@@ -859,9 +778,7 @@ void _IL_Thread_VolatileWrite_Rll(ILExecThread *thread,
void _IL_Thread_VolatileWrite_RLL(ILExecThread *thread,
ILUInt64
*address, ILUInt64 value)
{
- *((volatile ILUInt64 *)address) = value;
-
- ILInterlockedMemoryBarrier();
+ ILInterlockedStoreU8_Acquire(address, value);
}
/*
@@ -870,9 +787,7 @@ void _IL_Thread_VolatileWrite_RLL(ILExecThread *thread,
void _IL_Thread_VolatileWrite_Rjj(ILExecThread *thread,
ILNativeInt
*address, ILNativeInt value)
{
- *((volatile ILNativeInt *)address) = value;
-
- ILInterlockedMemoryBarrier();
+ ILInterlockedStoreP_Acquire((void **)address, (void *)value);
}
/*
@@ -881,9 +796,7 @@ void _IL_Thread_VolatileWrite_Rjj(ILExecThread *thread,
void _IL_Thread_VolatileWrite_RJJ(ILExecThread *thread,
ILNativeUInt
*address, ILNativeUInt value)
{
- *((volatile ILNativeUInt *)address) = value;
-
- ILInterlockedMemoryBarrier();
+ ILInterlockedStoreP_Acquire((void **)address, (void *)value);
}
/*
@@ -892,9 +805,7 @@ void _IL_Thread_VolatileWrite_RJJ(ILExecThread *thread,
void _IL_Thread_VolatileWrite_Rff(ILExecThread *thread,
ILFloat
*address, ILFloat value)
{
- *((volatile ILFloat *)address) = value;
-
- ILInterlockedMemoryBarrier();
+ ILInterlockedStoreR4_Acquire(address, value);
}
/*
@@ -903,9 +814,7 @@ void _IL_Thread_VolatileWrite_Rff(ILExecThread *thread,
void _IL_Thread_VolatileWrite_Rdd(ILExecThread *thread,
ILDouble
*address, ILDouble value)
{
- *((volatile ILDouble *)address) = value;
-
- ILInterlockedMemoryBarrier();
+ ILInterlockedStoreR8_Acquire(address, value);
}
/*
@@ -914,9 +823,7 @@ void _IL_Thread_VolatileWrite_Rdd(ILExecThread *thread,
void _IL_Thread_VolatileWrite_RObjectObject(ILExecThread *thread,
ILObject **address, ILObject *value)
{
- *((volatile ILObject * volatile *)address) = value;
-
- ILInterlockedMemoryBarrier();
+ ILInterlockedStoreP_Acquire((void **)address, (void *)value);
}
/*
diff --git a/engine/thread.c b/engine/thread.c
index 753271d..6dd7c6b 100644
--- a/engine/thread.c
+++ b/engine/thread.c
@@ -312,8 +312,8 @@ int _ILExecThreadSelfAborting(ILExecThread *thread)
exception =
_ILExecThreadNewThreadAbortException(thread, 0);
- ILInterlockedAnd(&(thread->managedSafePointFlags),
-
~_IL_MANAGED_SAFEPOINT_THREAD_ABORT);
+ ILInterlockedAndU4(&(thread->managedSafePointFlags),
+
~_IL_MANAGED_SAFEPOINT_THREAD_ABORT);
thread->aborting = 1;
thread->threadAbortException = 0;
#ifdef IL_USE_CVM
@@ -363,8 +363,8 @@ void _ILExecThreadResumeThread(ILExecThread *thread,
ILThread *supportThread)
}
/* Remove the _IL_MANAGED_SAFEPOINT_THREAD_SUSPEND flag */
- ILInterlockedAnd(&(execThread->managedSafePointFlags),
- ~_IL_MANAGED_SAFEPOINT_THREAD_SUSPEND);
+ ILInterlockedAndU4(&(execThread->managedSafePointFlags),
+
~_IL_MANAGED_SAFEPOINT_THREAD_SUSPEND);
/* Call the threading subsystem's resume */
ILThreadResume(supportThread);
@@ -451,8 +451,8 @@ void _ILExecThreadSuspendThread(ILExecThread *thread,
ILThread *supportThread)
flags, the engine needs to check the ThreadState after
checking the safepoint
flags (see cvm_call.c) */
- ILInterlockedOr(&(execThread->managedSafePointFlags),
-
_IL_MANAGED_SAFEPOINT_THREAD_SUSPEND);
+ ILInterlockedOrU4(&(execThread->managedSafePointFlags),
+
_IL_MANAGED_SAFEPOINT_THREAD_SUSPEND);
ILWaitMonitorLeave(monitor);
@@ -496,8 +496,8 @@ void _ILExecThreadAbortThread(ILExecThread *thread,
ILThread *supportThread)
{
/* Mark the flag so the thread self aborts when it next returns
to managed code */
- ILInterlockedOr(&(execThread->managedSafePointFlags),
-
_IL_MANAGED_SAFEPOINT_THREAD_ABORT);
+ ILInterlockedOrU4(&(execThread->managedSafePointFlags),
+
_IL_MANAGED_SAFEPOINT_THREAD_ABORT);
}
ILWaitMonitorLeave(monitor);
diff --git a/support/interlocked.h b/support/interlocked.h
index fce4f2c..0d673bb 100644
--- a/support/interlocked.h
+++ b/support/interlocked.h
@@ -88,61 +88,61 @@
*
* Exchange integers.
* Returns the original value at *dest.
- * define: IL_HAVE_INTERLOCKED_EXCHANGE
- * define: IL_HAVE_INTERLOCKED_EXCHANGE_ACQUIRE
- * define: IL_HAVE_INTERLOCKED_EXCHANGE_RELEASE
- * define: IL_HAVE_INTERLOCKED_EXCHANGE_FULL
+ * define: IL_HAVE_INTERLOCKED_EXCHANGEI4
+ * define: IL_HAVE_INTERLOCKED_EXCHANGEI4_ACQUIRE
+ * define: IL_HAVE_INTERLOCKED_EXCHANGEI4_RELEASE
+ * define: IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL
*
* ILInt32 ILInterlockedExchange(volatile ILInt32 *dest, ILInt32 value)
*
* Exchange pointers.
* Returns the original value at *dest
- * define: IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS
- * define: IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_ACQUIRE
- * define: IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_RELEASE
- * define: IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_FULL
+ * define: IL_HAVE_INTERLOCKED_EXCHANGEP
+ * define: IL_HAVE_INTERLOCKED_EXCHANGEP_ACQUIRE
+ * define: IL_HAVE_INTERLOCKED_EXCHANGEP_RELEASE
+ * define: IL_HAVE_INTERLOCKED_EXCHANGEP_FULL
*
- * void *ILInterlockedExchangePointers(void * volatile *dest, void *value)
+ * void *ILInterlockedExchangeP(void * volatile *dest, void *value)
*
* Compare and exchange two 32bit integers.
* Returns the original value at *dest
- * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE
- * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_ACQUIRE
- * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_RELEASE
- * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_FULL
+ * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4
+ * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_ACQUIRE
+ * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_RELEASE
+ * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL
*
- * ILInt32 ILInterlockedCompareAndExchange(volatile ILInt32 *dest,
- *
ILInt32 value,
- *
ILInt32 comparand)
+ * ILInt32 ILInterlockedCompareAndExchangeI4(volatile ILInt32 *dest,
+ *
ILInt32 value,
+ *
ILInt32 comparand)
*
* Compare and exchange two pointers.
* Returns the original value at *dest
- * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS
- * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_ACQUIRE
- * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_RELEASE
- * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_FULL
+ * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP
+ * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_ACQUIRE
+ * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_RELEASE
+ * define: IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL
*
- * void *ILInterlockedCompareAndExchangePointers(void * volatile *dest,
- *
void *value,
- *
void *comparand)
+ * void *ILInterlockedCompareAndExchangeP(void * volatile *dest,
+ *
void *value,
+ *
void *comparand)
*
* Add the 32 bit values *dest and value and store the result at *dest.
* Returns the result od the addition (new value at *dest)
- * define: IL_HAVE_INTERLOCKED_ADD
- * define: IL_HAVE_INTERLOCKED_ADD_ACQUIRE
- * define: IL_HAVE_INTERLOCKED_ADD_RELEASE
- * define: IL_HAVE_INTERLOCKED_ADD_FULL
+ * define: IL_HAVE_INTERLOCKED_ADDI4
+ * define: IL_HAVE_INTERLOCKED_ADDI4_ACQUIRE
+ * define: IL_HAVE_INTERLOCKED_ADDI4_RELEASE
+ * define: IL_HAVE_INTERLOCKED_ADDI4_FULL
*
- * ILInt32 ILInterlockedAdd(volatile ILInt32 *dest, ILInt32 value)
+ * ILInt32 ILInterlockedAddI4(volatile ILInt32 *dest, ILInt32 value)
*
* Substract the 32 bit values *dest and value and store the result at *dest.
* Returns the result od the subtraction (new value at *dest)
- * define: IL_HAVE_INTERLOCKED_SUB
- * define: IL_HAVE_INTERLOCKED_SUB_ACQUIRE
- * define: IL_HAVE_INTERLOCKED_SUB_RELEASE
- * define: IL_HAVE_INTERLOCKED_SUB_FULL
+ * define: IL_HAVE_INTERLOCKED_SUBI4
+ * define: IL_HAVE_INTERLOCKED_SUBI4_ACQUIRE
+ * define: IL_HAVE_INTERLOCKED_SUBI4_RELEASE
+ * define: IL_HAVE_INTERLOCKED_SUBI4_FULL
*
- * ILInt32 ILInterlockedSub(volatile ILInt32 *dest, ILInt32 value)
+ * ILInt32 ILInterlockedSubI4(volatile ILInt32 *dest, ILInt32 value)
*
* NOTE: If not defined by the arch specific definition it is a implemented
* by a macro that is using ILInterlockedAdd with value negated.
@@ -150,12 +150,12 @@
*
* Increment a 32bit integer.
* Returns the value of the incremented integer.
- * define: IL_HAVE_INTERLOCKED_INCREMENT
- * define: IL_HAVE_INTERLOCKED_INCREMENT_ACQUIRE
- * define: IL_HAVE_INTERLOCKED_INCREMENT_RELEASE
- * define: IL_HAVE_INTERLOCKED_INCREMENT_FULL
+ * define: IL_HAVE_INTERLOCKED_INCREMENTI4
+ * define: IL_HAVE_INTERLOCKED_INCREMENTI4_ACQUIRE
+ * define: IL_HAVE_INTERLOCKED_INCREMENTI4_RELEASE
+ * define: IL_HAVE_INTERLOCKED_INCREMENTI4_FULL
*
- * ILInt32 ILInterlockedIncrement(volatile ILInt32 *dest)
+ * ILInt32 ILInterlockedIncrementI4(volatile ILInt32 *dest)
*
* NOTE: If not defined by the arch specific definition it is a implemented
* by a macro that is using ILInterlockedAdd with a value of 1.
@@ -163,32 +163,32 @@
*
* Decrement a 32bit integer.
* Returns the value of the decremented integer.
- * define: IL_HAVE_INTERLOCKED_DECREMENT
- * define: IL_HAVE_INTERLOCKED_DECREMENT_ACQUIRE
- * define: IL_HAVE_INTERLOCKED_DECREMENT_RELEASE
- * define: IL_HAVE_INTERLOCKED_DECREMENT_FULL
+ * define: IL_HAVE_INTERLOCKED_DECREMENTI4
+ * define: IL_HAVE_INTERLOCKED_DECREMENTI4_ACQUIRE
+ * define: IL_HAVE_INTERLOCKED_DECREMENTI4_RELEASE
+ * define: IL_HAVE_INTERLOCKED_DECREMENTI4_FULL
*
- * ILInt32 ILInterlockedDecrement(volatile ILInt32 *dest)
+ * ILInt32 ILInterlockedDecrementI4(volatile ILInt32 *dest)
*
* NOTE: If not defined by the arch specific definition it is a implemented
* by a macro that is using ILInterlockedSub with a value of 1.
* (See interlocked_any.h)
*
* Bitwise AND of *dest and value and the result is stored at *dest
- * define: IL_HAVE_INTERLOCKED_AND
- * define: IL_HAVE_INTERLOCKED_AND_ACQUIRE
- * define: IL_HAVE_INTERLOCKED_AND_RELEASE
- * define: IL_HAVE_INTERLOCKED_AND_FULL
+ * define: IL_HAVE_INTERLOCKED_ANDU4
+ * define: IL_HAVE_INTERLOCKED_ANDU4_ACQUIRE
+ * define: IL_HAVE_INTERLOCKED_ANDU4_RELEASE
+ * define: IL_HAVE_INTERLOCKED_ANDU4_FULL
*
- * void ILInterlockedAnd(volatile ILUInt32 *dest, ILUInt32 value)
+ * void ILInterlockedAndU4(volatile ILUInt32 *dest, ILUInt32 value)
*
* Bitwise OR of *dest and value and the result is stored at *dest
- * define: IL_HAVE_INTERLOCKED_OR
- * define: IL_HAVE_INTERLOCKED_OR_ACQUIRE
- * define: IL_HAVE_INTERLOCKED_OR_RELEASE
- * define: IL_HAVE_INTERLOCKED_OR_FULL
+ * define: IL_HAVE_INTERLOCKED_ORU4
+ * define: IL_HAVE_INTERLOCKED_ORU4_ACQUIRE
+ * define: IL_HAVE_INTERLOCKED_ORU4_RELEASE
+ * define: IL_HAVE_INTERLOCKED_ORU4_FULL
*
- * void ILInterlockedOr(volatile ILUInt32 *dest, ILUInt32 value)
+ * void ILInterlockedOrU4(volatile ILUInt32 *dest, ILUInt32 value)
*
* NOTE: If archdependent versions with the _Aquire or _Release suffix
* are not defined they will be mapped to the version with the _Full suffix.
diff --git a/support/interlocked_any.h b/support/interlocked_any.h
index 87c011e..7c263e4 100644
--- a/support/interlocked_any.h
+++ b/support/interlocked_any.h
@@ -20,6 +20,21 @@
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
+/*
+ * Some helper types for conversions
+ */
+typedef union
+{
+ ILInt32 int32Value;
+ ILFloat floatValue;
+} ILInterlockedConv4;
+
+typedef union
+{
+ ILInt64 int64Value;
+ ILDouble doubleValue;
+} ILInterlockedConv8;
+
#if !defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
/*
* Flush cache and set a memory barrier.
@@ -32,891 +47,4768 @@ static IL_INLINE void ILInterlockedMemoryBarrier()
#endif /* !defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
/*
- * Load a 32 bit value from a location.
+ * Load a signed 8 bit value from a location.
+ */
+static IL_INLINE ILInt8 _ILInterlockedLoadI1(const volatile ILInt8 *dest)
+{
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * acquire semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the value is likely to be cached.
+ */
+ return *dest;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADI1)
+#define ILInterlockedLoadI1(dest) _ILInterlockedLoadI1((dest))
+#define IL_HAVE_INTERLOCKED_LOADI1 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI1) */
+
+static IL_INLINE ILInt8 _ILInterlockedLoadI1_Acquire(const volatile ILInt8
*dest)
+{
+ ILInt8 result;
+
+ result = ILInterlockedLoadI1(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADI1_ACQUIRE)
+#define ILInterlockedLoadI1_Acquire(dest)
_ILInterlockedLoadI1_Acquire((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADI1_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI1_ACQUIRE) */
+
+static IL_INLINE ILInt8 _ILInterlockedLoadI1_Release(const volatile ILInt8
*dest)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedLoadI1(dest);
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADI1_RELEASE)
+#define ILInterlockedLoadI1_Release(dest)
_ILInterlockedLoadI1_Release((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADI1_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI1_RELEASE) */
+
+static IL_INLINE ILInt8 _ILInterlockedLoadI1_Full(const volatile ILInt8 *dest)
+{
+ ILInt8 result;
+
+ ILInterlockedMemoryBarrier();
+ result = ILInterlockedLoadI1(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADI1_FULL)
+#define ILInterlockedLoadI1_Full(dest) _ILInterlockedLoadI1_Full((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADI1_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI1_FULL) */
+
+/*
+ * Load an unsigned 8 bit value from a location.
+ */
+static IL_INLINE ILUInt8 _ILInterlockedLoadU1(const volatile ILUInt8 *dest)
+{
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * acquire semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the value is likely to be cached.
+ */
+ return *dest;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU1)
+#define ILInterlockedLoadU1(dest) _ILInterlockedLoadU1((dest))
+#define IL_HAVE_INTERLOCKED_LOADU1 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU1) */
+
+static IL_INLINE ILUInt8 _ILInterlockedLoadU1_Acquire(const volatile ILUInt8
*dest)
+{
+ ILUInt8 result;
+
+ result = ILInterlockedLoadU1(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU1_ACQUIRE)
+#define ILInterlockedLoadU1_Acquire(dest)
_ILInterlockedLoadU1_Acquire((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADU1_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU1_ACQUIRE) */
+
+static IL_INLINE ILUInt8 _ILInterlockedLoadU1_Release(const volatile ILUInt8
*dest)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedLoadU1(dest);
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU1_RELEASE)
+#define ILInterlockedLoadU1_Release(dest)
_ILInterlockedLoadU1_Release((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADU1_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU1_RELEASE) */
+
+static IL_INLINE ILUInt8 _ILInterlockedLoadU1_Full(const volatile ILUInt8
*dest)
+{
+ ILUInt8 result;
+
+ ILInterlockedMemoryBarrier();
+ result = ILInterlockedLoadU1(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU1_FULL)
+#define ILInterlockedLoadU1_Full(dest) _ILInterlockedLoadU1_Full((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADU1_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU1_FULL) */
+
+/*
+ * Load a signed 16 bit value from a location.
+ */
+static IL_INLINE ILInt16 _ILInterlockedLoadI2(const volatile ILInt16 *dest)
+{
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * acquire semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the value is likely to be cached.
+ */
+ return *dest;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADI2)
+#define ILInterlockedLoadI2(dest) _ILInterlockedLoadI2((dest))
+#define IL_HAVE_INTERLOCKED_LOADI2 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI2) */
+
+static IL_INLINE ILInt16 _ILInterlockedLoadI2_Acquire(const volatile ILInt16
*dest)
+{
+ ILInt16 result;
+
+ result = ILInterlockedLoadI2(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADI2_ACQUIRE)
+#define ILInterlockedLoadI2_Acquire(dest)
_ILInterlockedLoadI2_Acquire((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADI2_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI2_ACQUIRE) */
+
+static IL_INLINE ILInt16 _ILInterlockedLoadI2_Release(const volatile ILInt16
*dest)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedLoadI2(dest);
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADI2_RELEASE)
+#define ILInterlockedLoadI2_Release(dest)
_ILInterlockedLoadI2_Release((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADI2_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI2_RELEASE) */
+
+static IL_INLINE ILInt16 _ILInterlockedLoadI2_Full(const volatile ILInt16
*dest)
+{
+ ILInt16 result;
+
+ ILInterlockedMemoryBarrier();
+ result = ILInterlockedLoadI2(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADI2_FULL)
+#define ILInterlockedLoadI2_Full(dest) _ILInterlockedLoadI2_Full((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADI2_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI2_FULL) */
+
+/*
+ * Load an unsigned 16 bit value from a location.
+ */
+static IL_INLINE ILUInt16 _ILInterlockedLoadU2(const volatile ILUInt16 *dest)
+{
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * acquire semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the value is likely to be cached.
+ */
+ return *dest;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU2)
+#define ILInterlockedLoadU2(dest) _ILInterlockedLoadU2((dest))
+#define IL_HAVE_INTERLOCKED_LOADU2 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU2) */
+
+static IL_INLINE ILUInt16 _ILInterlockedLoadU2_Acquire(const volatile ILUInt16
*dest)
+{
+ ILUInt16 result;
+
+ result = ILInterlockedLoadU2(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU2_ACQUIRE)
+#define ILInterlockedLoadU2_Acquire(dest)
_ILInterlockedLoadU2_Acquire((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADU2_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU2_ACQUIRE) */
+
+static IL_INLINE ILUInt16 _ILInterlockedLoadU2_Release(const volatile ILUInt16
*dest)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedLoadU2(dest);
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU2_RELEASE)
+#define ILInterlockedLoadU2_Release(dest)
_ILInterlockedLoadU2_Release((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADU2_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU2_RELEASE) */
+
+static IL_INLINE ILUInt16 _ILInterlockedLoadU2_Full(const volatile ILUInt16
*dest)
+{
+ ILUInt16 result;
+
+ ILInterlockedMemoryBarrier();
+ result = ILInterlockedLoadU2(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU2_FULL)
+#define ILInterlockedLoadU2_Full(dest) _ILInterlockedLoadU2_Full((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADU2_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU2_FULL) */
+
+/*
+ * Load a signed 32 bit value from a location.
*/
-static IL_INLINE ILInt32 _ILInterlockedLoad(const volatile ILInt32 *dest)
+static IL_INLINE ILInt32 _ILInterlockedLoadI4(const volatile ILInt32 *dest)
{
/*
- * Cast away the volatile because gcc will generate code with acquire
- * semantics on IA64 otherwise.
+ * We should cast away the volatile because gcc will generate code with
+ * acquire semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the value is likely to be cached.
*/
- return *(ILInt32 *)dest;
+ return *dest;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADI4)
+#define ILInterlockedLoadI4(dest) _ILInterlockedLoadI4((dest))
+#define IL_HAVE_INTERLOCKED_LOADI4 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI4) */
+
+static IL_INLINE ILInt32 _ILInterlockedLoadI4_Acquire(const volatile ILInt32
*dest)
+{
+ ILInt32 result;
+
+ result = ILInterlockedLoadI4(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADI4_ACQUIRE)
+#define ILInterlockedLoadI4_Acquire(dest)
_ILInterlockedLoadI4_Acquire((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADI4_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI4_ACQUIRE) */
+
+static IL_INLINE ILInt32 _ILInterlockedLoadI4_Release(const volatile ILInt32
*dest)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedLoadI4(dest);
}
-#if !defined(IL_HAVE_INTERLOCKED_LOAD)
-#define ILInterlockedLoad(dest) _ILInterlockedLoad((dest))
-#endif /* !defined(IL_HAVE_INTERLOCKED_LOAD) */
+#if !defined(IL_HAVE_INTERLOCKED_LOADI4_RELEASE)
+#define ILInterlockedLoadI4_Release(dest)
_ILInterlockedLoadI4_Release((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADI4_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI4_RELEASE) */
+
+static IL_INLINE ILInt32 _ILInterlockedLoadI4_Full(const volatile ILInt32
*dest)
+{
+ ILInt32 result;
+
+ ILInterlockedMemoryBarrier();
+ result = ILInterlockedLoadI4(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADI4_FULL)
+#define ILInterlockedLoadI4_Full(dest) _ILInterlockedLoadI4_Full((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADI4_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU4_FULL) */
/*
- * Load a 32 bit value from a location with acquire semantics.
+ * Load an unsigned 32 bit value from a location.
*/
-static IL_INLINE ILInt32 _ILInterlockedLoad_Acquire(const volatile ILInt32
*dest)
+static IL_INLINE ILUInt32 _ILInterlockedLoadU4(const volatile ILUInt32 *dest)
+{
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * acquire semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the value is likely to be cached.
+ */
+ return *dest;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU4)
+#define ILInterlockedLoadU4(dest) _ILInterlockedLoadU4((dest))
+#define IL_HAVE_INTERLOCKED_LOADU4 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU4) */
+
+static IL_INLINE ILUInt32 _ILInterlockedLoadU4_Acquire(const volatile ILUInt32
*dest)
{
- ILInt32 value;
+ ILUInt32 result;
- value = *dest;
- ILInterlockedCompilerBarrier;
- return value;
+ result = ILInterlockedLoadU4(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
}
-#if !defined(IL_HAVE_INTERLOCKED_LOAD_ACQUIRE)
-#define ILInterlockedLoad_Acquire(dest)
_ILInterlockedLoad_Acquire((dest))
-#endif /* !defined(IL_HAVE_INTERLOCKED_LOAD_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_LOADU4_ACQUIRE)
+#define ILInterlockedLoadU4_Acquire(dest)
_ILInterlockedLoadU4_Acquire((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADU4_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU4_ACQUIRE) */
+
+static IL_INLINE ILUInt32 _ILInterlockedLoadU4_Release(const volatile ILUInt32
*dest)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedLoadU4(dest);
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU4_RELEASE)
+#define ILInterlockedLoadU4_Release(dest)
_ILInterlockedLoadU4_Release((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADU4_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU4_RELEASE) */
+
+static IL_INLINE ILUInt32 _ILInterlockedLoadU4_Full(const volatile ILUInt32
*dest)
+{
+ ILUInt32 result;
+
+ ILInterlockedMemoryBarrier();
+ result = ILInterlockedLoadU4(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU4_FULL)
+#define ILInterlockedLoadU4_Full(dest) _ILInterlockedLoadU4_Full((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADU4_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU4_FULL) */
/*
* Load a pointer value from a location.
*/
-static IL_INLINE void * _ILInterlockedLoadPointer(void * const volatile *dest)
+static IL_INLINE void *_ILInterlockedLoadP(void * const volatile *dest)
{
/*
- * Cast away the volatile because gcc will generate code with acquire
- * semantics on IA64 otherwise.
+ * We should cast away the volatile because gcc will generate code with
+ * acquire semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the value is likely to be cached.
*/
- return *(void **)dest;
+ return *dest;
}
-#if !defined(IL_HAVE_INTERLOCKED_LOADPOINTER)
-#define ILInterlockedLoadPointer(dest) _ILInterlockedLoadPointer((dest))
-#endif /* !defined(IL_HAVE_INTERLOCKED_LOADPOINTER) */
+#if !defined(IL_HAVE_INTERLOCKED_LOADP)
+#define ILInterlockedLoadP(dest) _ILInterlockedLoadP((dest))
+#define IL_HAVE_INTERLOCKED_LOADP 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADP) */
+
+static IL_INLINE void *_ILInterlockedLoadP_Acquire(void * const volatile *dest)
+{
+ void *result;
+
+ result = ILInterlockedLoadP(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADP_ACQUIRE)
+#define ILInterlockedLoadP_Acquire(dest)
_ILInterlockedLoadP_Acquire((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADP_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADP_ACQUIRE) */
+
+static IL_INLINE void *_ILInterlockedLoadP_Release(void * const volatile *dest)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedLoadP(dest);
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADP_RELEASE)
+#define ILInterlockedLoadP_Release(dest)
_ILInterlockedLoadP_Release((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADP_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADP_RELEASE) */
+
+static IL_INLINE void *_ILInterlockedLoadP_Full(void * const volatile *dest)
+{
+ void *result;
+
+ ILInterlockedMemoryBarrier();
+ result = ILInterlockedLoadP(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADP_FULL)
+#define ILInterlockedLoadP_Full(dest) _ILInterlockedLoadP_Full((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADP_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADP_FULL) */
/*
- * Load a pointer value from a location with acquire semantics.
+ * Load a single precision floatingpoint value from a location.
*/
-static IL_INLINE void *_ILInterlockedLoadPointer_Acquire(void * const volatile
*dest)
+static IL_INLINE ILFloat _ILInterlockedLoadR4(const volatile ILFloat *dest)
{
- void *value;
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * acquire semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the value is likely to be cached.
+ */
+ return *dest;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADR4)
+#define ILInterlockedLoadR4(dest) _ILInterlockedLoadR4((dest))
+#define IL_HAVE_INTERLOCKED_LOADR4 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADR4) */
+
+static IL_INLINE ILFloat _ILInterlockedLoadR4_Acquire(const volatile ILFloat
*dest)
+{
+ ILFloat result;
+
+ result = ILInterlockedLoadR4(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADR4_ACQUIRE)
+#define ILInterlockedLoadR4_Acquire(dest)
_ILInterlockedLoadR4_Acquire((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADR4_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADR4_ACQUIRE) */
- value = *dest;
- ILInterlockedCompilerBarrier;
- return value;
+static IL_INLINE ILFloat _ILInterlockedLoadR4_Release(const volatile ILFloat
*dest)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedLoadR4(dest);
}
-#if !defined(IL_HAVE_INTERLOCKED_LOADPOINTER_ACQUIRE)
-#define ILInterlockedLoadPointer_Acquire(dest)
_ILInterlockedLoadPointer_Acquire((dest))
-#endif /* !defined(IL_HAVE_INTERLOCKED_LOADPOINTER_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_LOADR4_RELEASE)
+#define ILInterlockedLoadR4_Release(dest)
_ILInterlockedLoadR4_Release((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADR4_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADR4_RELEASE) */
+static IL_INLINE ILFloat _ILInterlockedLoadR4_Full(const volatile ILFloat
*dest)
+{
+ ILFloat result;
+
+ ILInterlockedMemoryBarrier();
+ result = ILInterlockedLoadR4(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADR4_FULL)
+#define ILInterlockedLoadR4_Full(dest) _ILInterlockedLoadR4_Full((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADR4_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADR4_FULL) */
+
+#if defined(IL_NATIVE_INT64)
/*
- * Store a 32 bit value to a location.
+ * Load a signed 64 bit value from a location.
*/
-static IL_INLINE void _ILInterlockedStore(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt64 _ILInterlockedLoadI8(const volatile ILInt64 *dest)
{
/*
- * Cast away the volatile because gcc will generate code with release
- * semantics on IA64 otherwise.
+ * We should cast away the volatile because gcc will generate code with
+ * acquire semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the value is likely to be cached.
*/
- *(ILInt32 *)dest = value;
+ return *dest;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADI8)
+#define ILInterlockedLoadI8(dest) _ILInterlockedLoadI8((dest))
+#define IL_HAVE_INTERLOCKED_LOADI8 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI8) */
+
+static IL_INLINE ILInt64 _ILInterlockedLoadI8_Acquire(const volatile ILInt64
*dest)
+{
+ ILInt64 result;
+
+ result = ILInterlockedLoadI8(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
}
-#if !defined(IL_HAVE_INTERLOCKED_STORE)
-#define ILInterlockedStore(dest, value) _ILInterlockedStore((dest),
(value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_STORE) */
+#if !defined(IL_HAVE_INTERLOCKED_LOADI8_ACQUIRE)
+#define ILInterlockedLoadI8_Acquire(dest)
_ILInterlockedLoadI8_Acquire((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADI8_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI8_ACQUIRE) */
+
+static IL_INLINE ILInt64 _ILInterlockedLoadI8_Release(const volatile ILInt64
*dest)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedLoadI8(dest);
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADI8_RELEASE)
+#define ILInterlockedLoadI8_Release(dest)
_ILInterlockedLoadI8_Release((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADI8_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI8_RELEASE) */
+
+static IL_INLINE ILInt64 _ILInterlockedLoadI8_Full(const volatile ILInt64
*dest)
+{
+ ILInt64 result;
+
+ ILInterlockedMemoryBarrier();
+ result = ILInterlockedLoadI8(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADI8_FULL)
+#define ILInterlockedLoadI8_Full(dest) _ILInterlockedLoadI8_Full((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADI8_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI8_FULL) */
/*
- * Store a 32 bit value to a location with release semantics.
+ * Load an unsigned 64 bit value from a location.
*/
-static IL_INLINE void _ILInterlockedStore_Release(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILUInt64 _ILInterlockedLoadU8(const volatile ILUInt64 *dest)
+{
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * acquire semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the value is likely to be cached.
+ */
+ return *dest;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU8)
+#define ILInterlockedLoadU8(dest) _ILInterlockedLoadU8((dest))
+#define IL_HAVE_INTERLOCKED_LOADU8 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU8) */
+
+static IL_INLINE ILUInt64 _ILInterlockedLoadU8_Acquire(const volatile ILUInt64
*dest)
+{
+ ILUInt64 result;
+
+ result = ILInterlockedLoadU8(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU8_ACQUIRE)
+#define ILInterlockedLoadU8_Acquire(dest)
_ILInterlockedLoadU8_Acquire((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADU8_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU8_ACQUIRE) */
+
+static IL_INLINE ILUInt64 _ILInterlockedLoadU8_Release(const volatile ILUInt64
*dest)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedLoadU8(dest);
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU8_RELEASE)
+#define ILInterlockedLoadU8_Release(dest)
_ILInterlockedLoadU8_Release((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADU8_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU8_RELEASE) */
+
+static IL_INLINE ILUInt64 _ILInterlockedLoadU8_Full(const volatile ILUInt64
*dest)
+{
+ ILUInt64 result;
+
+ ILInterlockedMemoryBarrier();
+ result = ILInterlockedLoadU8(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU8_FULL)
+#define ILInterlockedLoadU8_Full(dest) _ILInterlockedLoadU8_Full((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADU8_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU8_FULL) */
+
+/*
+ * Load a double precision floatingpoint value from a location.
+ */
+static IL_INLINE ILDouble _ILInterlockedLoadR8(const volatile ILDouble *dest)
+{
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * acquire semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the value is likely to be cached.
+ */
+ return *dest;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADR8)
+#define ILInterlockedLoadR8(dest) _ILInterlockedLoadR8((dest))
+#define IL_HAVE_INTERLOCKED_LOADR8 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADR8) */
+
+static IL_INLINE ILDouble _ILInterlockedLoadR8_Acquire(const volatile ILDouble
*dest)
+{
+ ILDouble result;
+
+ result = ILInterlockedLoadR8(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADR8_ACQUIRE)
+#define ILInterlockedLoadR8_Acquire(dest)
_ILInterlockedLoadR8_Acquire((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADR8_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADR8_ACQUIRE) */
+
+static IL_INLINE ILDouble _ILInterlockedLoadR8_Release(const volatile ILDouble
*dest)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedLoadR8(dest);
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADR8_RELEASE)
+#define ILInterlockedLoadR8_Release(dest)
_ILInterlockedLoadR8_Release((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADR8_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADR8_RELEASE) */
+
+static IL_INLINE ILDouble _ILInterlockedLoadR8_Full(const volatile ILDouble
*dest)
+{
+ ILDouble result;
+
+ ILInterlockedMemoryBarrier();
+ result = ILInterlockedLoadR8(dest);
+ ILInterlockedMemoryBarrier();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADR8_FULL)
+#define ILInterlockedLoadR8_Full(dest) _ILInterlockedLoadR8_Full((dest))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_LOADR8_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADR8_FULL) */
+#else /* !defined(IL_NATIVE_INT64) */
+/*
+ * Load a signed 64 bit value from a location.
+ */
+static IL_INLINE ILInt64 _ILInterlockedLoadI8_Full(const volatile ILInt64
*dest)
+{
+ ILInt64 result;
+
+ ILThreadAtomicStart();
+ result = *dest;
+ ILThreadAtomicEnd();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADI8)
+#define ILInterlockedLoadI8(dest) _ILInterlockedLoadI8_Full((dest))
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI8) */
+#if !defined(IL_HAVE_INTERLOCKED_LOADI8_ACQUIRE)
+#define ILInterlockedLoadI8_Acquire(dest)
_ILInterlockedLoadI8_Full((dest))
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_LOADI8_RELEASE)
+#define ILInterlockedLoadI8_Release(dest)
_ILInterlockedLoadI8_Full((dest))
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_LOADI8_FULL)
+#define ILInterlockedLoadI8_Full(dest) _ILInterlockedLoadI8_Full((dest))
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADI8_FULL) */
+
+/*
+ * Load an unsigned 64 bit value from a location.
+ */
+static IL_INLINE ILUInt64 _ILInterlockedLoadU8_Full(const volatile ILUInt64
*dest)
+{
+ ILUInt64 result;
+
+ ILThreadAtomicStart();
+ result = *dest;
+ ILThreadAtomicEnd();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADU8)
+#define ILInterlockedLoadU8(dest) _ILInterlockedLoadU8_Full((dest))
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU8) */
+#if !defined(IL_HAVE_INTERLOCKED_LOADU8_ACQUIRE)
+#define ILInterlockedLoadU8_Acquire(dest)
_ILInterlockedLoadU8_Full((dest))
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_LOADU8_RELEASE)
+#define ILInterlockedLoadU8_Release(dest)
_ILInterlockedLoadU8_Full((dest))
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_LOADU8_FULL)
+#define ILInterlockedLoadU8_Full(dest) _ILInterlockedLoadU8_Full((dest))
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADU8_FULL) */
+
+/*
+ * Load a double precision floatingpoint value from a location.
+ */
+static IL_INLINE ILDouble _ILInterlockedLoadR8_Full(const volatile ILDouble
*dest)
+{
+ ILDouble result;
+
+ ILThreadAtomicStart();
+ result = *dest;
+ ILThreadAtomicEnd();
+ return result;
+}
+#if !defined(IL_HAVE_INTERLOCKED_LOADR8)
+#define ILInterlockedLoadR8(dest) _ILInterlockedLoadR8_Full((dest))
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADR8) */
+#if !defined(IL_HAVE_INTERLOCKED_LOADR8_ACQUIRE)
+#define ILInterlockedLoadR8_Acquire(dest)
_ILInterlockedLoadR8_Full((dest))
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADR8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_LOADR8_RELEASE)
+#define ILInterlockedLoadR8_Release(dest)
_ILInterlockedLoadR8_Full((dest))
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADR8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_LOADR8_FULL)
+#define ILInterlockedLoadR8_Full(dest) _ILInterlockedLoadR8_Full((dest))
+#endif /* !defined(IL_HAVE_INTERLOCKED_LOADR8_FULL) */
+#endif /* !defined(IL_NATIVE_INT64) */
+
+/*
+ * Store a signed 8 bit value to a location.
+ */
+static IL_INLINE void _ILInterlockedStoreI1(volatile ILInt8 *dest,
+
ILInt8 value)
+{
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * release semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the store is likely to be optimized away.
+ */
+ *dest = value;
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI1)
+#define ILInterlockedStoreI1(dest, value) _ILInterlockedStoreI1((dest),
(value))
+#define IL_HAVE_INTERLOCKED_STOREI1 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI1) */
+
+static IL_INLINE void _ILInterlockedStoreI1_Acquire(volatile ILInt8 *dest,
+
ILInt8 value)
+{
+ ILInterlockedStoreI1(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI1_ACQUIRE)
+#define ILInterlockedStoreI1_Acquire(dest, value) \
+ _ILInterlockedStoreI1_Acquire((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREI1_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI1_ACQUIRE) */
+
+static IL_INLINE void _ILInterlockedStoreI1_Release(volatile ILInt8 *dest,
+
ILInt8 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreI1(dest, value);
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI1_RELEASE)
+#define ILInterlockedStoreI1_Release(dest, value) \
+ _ILInterlockedStoreI1_Release((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREI1_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI1_RELEASE) */
+
+static IL_INLINE void _ILInterlockedStoreI1_Full(volatile ILInt8 *dest,
+
ILInt8 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreI1(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI1_FULL)
+#define ILInterlockedStoreI1_Full(dest, value) \
+ _ILInterlockedStoreI1_Full((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREI1_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI1_RELEASE) */
+
+/*
+ * Store an unsigned 8 bit value to a location.
+ */
+static IL_INLINE void _ILInterlockedStoreU1(volatile ILUInt8 *dest,
+
ILUInt8 value)
+{
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * release semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the store is likely to be optimized away.
+ */
+ *dest = value;
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU1)
+#define ILInterlockedStoreU1(dest, value) _ILInterlockedStoreU1((dest),
(value))
+#define IL_HAVE_INTERLOCKED_STOREU1 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU1) */
+
+static IL_INLINE void _ILInterlockedStoreU1_Acquire(volatile ILUInt8 *dest,
+
ILUInt8 value)
+{
+ ILInterlockedStoreU1(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU1_ACQUIRE)
+#define ILInterlockedStoreU1_Acquire(dest, value) \
+ _ILInterlockedStoreU1_Acquire((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREU1_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU1_ACQUIRE) */
+
+static IL_INLINE void _ILInterlockedStoreU1_Release(volatile ILUInt8 *dest,
+
ILUInt8 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreU1(dest, value);
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU1_RELEASE)
+#define ILInterlockedStoreU1_Release(dest, value) \
+ _ILInterlockedStoreU1_Release((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREU1_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU1_RELEASE) */
+
+static IL_INLINE void _ILInterlockedStoreU1_Full(volatile ILUInt8 *dest,
+
ILUInt8 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreU1(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU1_FULL)
+#define ILInterlockedStoreU1_Full(dest, value) \
+ _ILInterlockedStoreU1_Full((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREU1_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU1_FULL) */
+
+/*
+ * Store a signed 16 bit value to a location.
+ */
+static IL_INLINE void _ILInterlockedStoreI2(volatile ILInt16 *dest,
+
ILInt16 value)
+{
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * release semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the store is likely to be optimized away.
+ */
+ *dest = value;
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI2)
+#define ILInterlockedStoreI2(dest, value) _ILInterlockedStoreI2((dest),
(value))
+#define IL_HAVE_INTERLOCKED_STOREI2 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI2) */
+
+static IL_INLINE void _ILInterlockedStoreI2_Acquire(volatile ILInt16 *dest,
+
ILInt16 value)
+{
+ ILInterlockedStoreI2(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI2_ACQUIRE)
+#define ILInterlockedStoreI2_Acquire(dest, value) \
+ _ILInterlockedStoreI2_Acquire((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREI2_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI2_ACQUIRE) */
+
+static IL_INLINE void _ILInterlockedStoreI2_Release(volatile ILInt16 *dest,
+
ILInt16 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreI2(dest, value);
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI2_RELEASE)
+#define ILInterlockedStoreI2_Release(dest, value) \
+ _ILInterlockedStoreI2_Release((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREI2_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI2_RELEASE) */
+
+static IL_INLINE void _ILInterlockedStoreI2_Full(volatile ILInt16 *dest,
+
ILInt16 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreI2(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI2_FULL)
+#define ILInterlockedStoreI2_Full(dest, value) \
+ _ILInterlockedStoreI2_Full((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREI2_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI2_FULL) */
+
+/*
+ * Store an unsigned 16 bit value to a location.
+ */
+static IL_INLINE void _ILInterlockedStoreU2(volatile ILUInt16 *dest,
+
ILUInt16 value)
{
- ILInterlockedCompilerBarrier;
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * release semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the store is likely to be optimized away.
+ */
*dest = value;
}
-#if !defined(IL_HAVE_INTERLOCKED_STORE_RELEASE)
-#define ILInterlockedStore_Release(dest, value) \
- _ILInterlockedStore_Release((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_STORE_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_STOREU2)
+#define ILInterlockedStoreU2(dest, value) _ILInterlockedStoreU2((dest),
(value))
+#define IL_HAVE_INTERLOCKED_STOREU2 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU2) */
+
+static IL_INLINE void _ILInterlockedStoreU2_Acquire(volatile ILUInt16 *dest,
+
ILUInt16 value)
+{
+ ILInterlockedStoreU2(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU2_ACQUIRE)
+#define ILInterlockedStoreU2_Acquire(dest, value) \
+ _ILInterlockedStoreU2_Acquire((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREU2_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU2_ACQUIRE) */
+
+static IL_INLINE void _ILInterlockedStoreU2_Release(volatile ILUInt16 *dest,
+
ILUInt16 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreU2(dest, value);
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU2_RELEASE)
+#define ILInterlockedStoreU2_Release(dest, value) \
+ _ILInterlockedStoreU2_Release((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREU2_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU2_RELEASE) */
+
+static IL_INLINE void _ILInterlockedStoreU2_Full(volatile ILUInt16 *dest,
+
ILUInt16 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreU2(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU2_FULL)
+#define ILInterlockedStoreU2_Full(dest, value) \
+ _ILInterlockedStoreU2_Full((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREU2_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU2_FULL) */
+
+/*
+ * Store a signed 32 bit value to a location.
+ */
+static IL_INLINE void _ILInterlockedStoreI4(volatile ILInt32 *dest,
+
ILInt32 value)
+{
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * release semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the store is likely to be optimized away.
+ */
+ *dest = value;
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI4)
+#define ILInterlockedStoreI4(dest, value) _ILInterlockedStoreI4((dest),
(value))
+#define IL_HAVE_INTERLOCKED_STOREI4 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI4) */
+
+static IL_INLINE void _ILInterlockedStoreI4_Acquire(volatile ILInt32 *dest,
+
ILInt32 value)
+{
+ ILInterlockedStoreI4(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI4_ACQUIRE)
+#define ILInterlockedStoreI4_Acquire(dest, value) \
+ _ILInterlockedStoreI4_Acquire((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREI4_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI4_ACQUIRE) */
+
+static IL_INLINE void _ILInterlockedStoreI4_Release(volatile ILInt32 *dest,
+
ILInt32 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreI4(dest, value);
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI4_RELEASE)
+#define ILInterlockedStoreI4_Release(dest, value) \
+ _ILInterlockedStoreI4_Release((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREI4_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI4_RELEASE) */
+
+static IL_INLINE void _ILInterlockedStoreI4_Full(volatile ILInt32 *dest,
+
ILInt32 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreI4(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI4_FULL)
+#define ILInterlockedStoreI4_Full(dest, value) \
+ _ILInterlockedStoreI4_Full((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREI4_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI4_FULL) */
+
+/*
+ * Store an unsigned 32 bit value to a location.
+ */
+static IL_INLINE void _ILInterlockedStoreU4(volatile ILUInt32 *dest,
+
ILUInt32 value)
+{
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * release semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the store is likely to be optimized away.
+ */
+ *dest = value;
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU4)
+#define ILInterlockedStoreU4(dest, value) _ILInterlockedStoreU4((dest),
(value))
+#define IL_HAVE_INTERLOCKED_STOREU4 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU4) */
+
+static IL_INLINE void _ILInterlockedStoreU4_Acquire(volatile ILUInt32 *dest,
+
ILUInt32 value)
+{
+ ILInterlockedStoreU4(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU4_ACQUIRE)
+#define ILInterlockedStoreU4_Acquire(dest, value) \
+ _ILInterlockedStoreU4_Acquire((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREU4_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU4_ACQUIRE) */
+
+static IL_INLINE void _ILInterlockedStoreU4_Release(volatile ILUInt32 *dest,
+
ILUInt32 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreU4(dest, value);
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU4_RELEASE)
+#define ILInterlockedStoreU4_Release(dest, value) \
+ _ILInterlockedStoreU4_Release((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREU4_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU4_RELEASE) */
+
+static IL_INLINE void _ILInterlockedStoreU4_Full(volatile ILUInt32 *dest,
+
ILUInt32 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreU4(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU4_FULL)
+#define ILInterlockedStoreU4_Full(dest, value) \
+ _ILInterlockedStoreU4_Full((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREU4_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU4_FULL) */
/*
* Store a pointer value to a location.
*/
-static IL_INLINE void _ILInterlockedStorePointer(void * volatile *dest,
-
void *value)
+static IL_INLINE void _ILInterlockedStoreP(void * volatile *dest,
+
void *value)
+{
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * release semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the store is likely to be optimized away.
+ */
+ *dest = value;
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREP)
+#define ILInterlockedStoreP(dest, value) _ILInterlockedStoreP((dest),
(value))
+#define IL_HAVE_INTERLOCKED_STOREP 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREP) */
+
+static IL_INLINE void _ILInterlockedStoreP_Acquire(void * volatile *dest,
+
void *value)
+{
+ ILInterlockedStoreP(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREP_ACQUIRE)
+#define ILInterlockedStoreP_Acquire(dest, value) \
+ _ILInterlockedStoreP_Acquire((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREP_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREP_ACQUIRE) */
+
+static IL_INLINE void _ILInterlockedStoreP_Release(void * volatile *dest,
+
void *value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreP(dest, value);
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREP_RELEASE)
+#define ILInterlockedStoreP_Release(dest, value) \
+ _ILInterlockedStoreP_Release((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREP_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREP_RELEASE) */
+
+static IL_INLINE void _ILInterlockedStoreP_Full(void * volatile *dest,
+
void *value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreP(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREP_FULL)
+#define ILInterlockedStoreP_Full(dest, value) \
+ _ILInterlockedStoreP_Full((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREP_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREP_FULL) */
+
+/*
+ * Store a single precision floatingpoint value to a location.
+ */
+static IL_INLINE void _ILInterlockedStoreR4(volatile ILFloat *dest,
+
ILFloat value)
{
/*
- * Cast away the volatile because gcc will generate code with release
- * semantics on IA64 otherwise.
+ * We should cast away the volatile because gcc will generate code with
+ * release semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the store is likely to be optimized away.
*/
- *(void **)dest = value;
+ *dest = value;
+}
+#if !defined(IL_HAVE_INTERLOCKED_STORER4)
+#define ILInterlockedStoreR4(dest, value) _ILInterlockedStoreR4((dest),
(value))
+#define IL_HAVE_INTERLOCKED_STORER4 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_STORER4) */
+
+static IL_INLINE void _ILInterlockedStoreR4_Acquire(volatile ILFloat *dest,
+
ILFloat value)
+{
+ ILInterlockedStoreR4(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STORER4_ACQUIRE)
+#define ILInterlockedStoreR4_Acquire(dest, value) \
+ _ILInterlockedStoreR4_Acquire((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STORER4_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STORER4_ACQUIRE) */
+
+static IL_INLINE void _ILInterlockedStoreR4_Release(volatile ILFloat *dest,
+
ILFloat value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreR4(dest, value);
+}
+#if !defined(IL_HAVE_INTERLOCKED_STORER4_RELEASE)
+#define ILInterlockedStoreR4_Release(dest, value) \
+ _ILInterlockedStoreR4_Release((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STORER4_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STORER4_RELEASE) */
+
+static IL_INLINE void _ILInterlockedStoreR4_Full(volatile ILFloat *dest,
+
ILFloat value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreR4(dest, value);
+ ILInterlockedMemoryBarrier();
}
-#if !defined(IL_HAVE_INTERLOCKED_STOREPOINTER)
-#define ILInterlockedStorePointer(dest, value) \
- _ILInterlockedStorePointer((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_STOREPOINTER) */
+#if !defined(IL_HAVE_INTERLOCKED_STORER4_FULL)
+#define ILInterlockedStoreR4_Full(dest, value) \
+ _ILInterlockedStoreR4_Full((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STORER4_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STORER4_FULL) */
+#if defined(IL_NATIVE_INT64)
/*
- * Store a pointer value to a location with release semantics.
+ * Store a signed 64 bit value to a location.
*/
-static IL_INLINE void _ILInterlockedStorePointer_Release(void * volatile *dest,
-
void *value)
+static IL_INLINE void _ILInterlockedStoreI8(volatile ILInt64 *dest,
+
ILInt64 value)
{
- ILInterlockedCompilerBarrier;
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * release semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the store is likely to be optimized away.
+ */
*dest = value;
}
-#if !defined(IL_HAVE_INTERLOCKED_STOREPOINTER_RELEASE)
-#define ILInterlockedStorePointer_Release(dest, value) \
- _ILInterlockedStorePointer_Release((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_STOREPOINTER_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_STOREI8)
+#define ILInterlockedStoreI8(dest, value) _ILInterlockedStoreI8((dest),
(value))
+#define IL_HAVE_INTERLOCKED_STOREI8 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI8) */
+
+static IL_INLINE void _ILInterlockedStoreI8_Acquire(volatile ILInt64 *dest,
+
ILInt64 value)
+{
+ ILInterlockedStoreI8(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI8_ACQUIRE)
+#define ILInterlockedStoreI8_Acquire(dest, value) \
+ _ILInterlockedStoreI8_Acquire((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREI8_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI8_ACQUIRE) */
+
+static IL_INLINE void _ILInterlockedStoreI8_Release(volatile ILInt64 *dest,
+
ILInt64 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreI8(dest, value);
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI8_RELEASE)
+#define ILInterlockedStoreI8_Release(dest, value) \
+ _ILInterlockedStoreI8_Release((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREI8_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI8_RELEASE) */
+
+static IL_INLINE void _ILInterlockedStoreI8_Full(volatile ILInt64 *dest,
+
ILInt64 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreI8(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI8_FULL)
+#define ILInterlockedStoreI8_Full(dest, value) \
+ _ILInterlockedStoreI8_Full((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREI8_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI8_FULL) */
/*
- * Exchange integers.
+ * Store an unsigned 64 bit value to a location.
*/
-static IL_INLINE ILInt32 _ILInterlockedExchange(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE void _ILInterlockedStoreU8(volatile ILUInt64 *dest,
+
ILUInt64 value)
{
- ILInt32 retval;
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * release semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the store is likely to be optimized away.
+ */
+ *dest = value;
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU8)
+#define ILInterlockedStoreU8(dest, value) _ILInterlockedStoreU8((dest),
(value))
+#define IL_HAVE_INTERLOCKED_STOREU8 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU8) */
+
+static IL_INLINE void _ILInterlockedStoreU8_Acquire(volatile ILUInt64 *dest,
+
ILUInt64 value)
+{
+ ILInterlockedStoreU8(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU8_ACQUIRE)
+#define ILInterlockedStoreU8_Acquire(dest, value) \
+ _ILInterlockedStoreU8_Acquire((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREU8_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU8_ACQUIRE) */
+static IL_INLINE void _ILInterlockedStoreU8_Release(volatile ILUInt64 *dest,
+
ILUInt64 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreU8(dest, value);
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU8_RELEASE)
+#define ILInterlockedStoreU8_Release(dest, value) \
+ _ILInterlockedStoreU8_Release((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREU8_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU8_RELEASE) */
+
+static IL_INLINE void _ILInterlockedStoreU8_Full(volatile ILUInt64 *dest,
+
ILUInt64 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreU8(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU8_FULL)
+#define ILInterlockedStoreU8_Full(dest, value) \
+ _ILInterlockedStoreU8_Full((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STOREU8_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU8_FULL) */
+
+/*
+ * Store a double precision floatingpoint value to a location.
+ */
+static IL_INLINE void _ILInterlockedStoreR8(volatile ILDouble *dest,
+
ILDouble value)
+{
+ /*
+ * We should cast away the volatile because gcc will generate code with
+ * release semantics on IA64 otherwise but at least on the x86 family
the
+ * volatile semantics needed (and what's volatile is for) gets lost and
+ * the store is likely to be optimized away.
+ */
+ *dest = value;
+}
+#if !defined(IL_HAVE_INTERLOCKED_STORER8)
+#define ILInterlockedStoreR8(dest, value) _ILInterlockedStoreR8((dest),
(value))
+#define IL_HAVE_INTERLOCKED_STORER8 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_STORER8) */
+
+static IL_INLINE void _ILInterlockedStoreR8_Acquire(volatile ILDouble *dest,
+
ILDouble value)
+{
+ ILInterlockedStoreR8(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STORER8_ACQUIRE)
+#define ILInterlockedStoreR8_Acquire(dest, value) \
+ _ILInterlockedStoreR8_Acquire((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STORER8_ACQUIRE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STORER8_ACQUIRE) */
+
+static IL_INLINE void _ILInterlockedStoreR8_Release(volatile ILDouble *dest,
+
ILDouble value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreR8(dest, value);
+}
+#if !defined(IL_HAVE_INTERLOCKED_STORER8_RELEASE)
+#define ILInterlockedStoreR8_Release(dest, value) \
+ _ILInterlockedStoreR8_Release((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STORER8_RELEASE 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STORER8_RELEASE) */
+
+static IL_INLINE void _ILInterlockedStoreR8_Full(volatile ILDouble *dest,
+
ILDouble value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedStoreR8(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STORER8_FULL)
+#define ILInterlockedStoreR8_Full(dest, value) \
+ _ILInterlockedStoreR8_Full((dest), (value))
+#if defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER)
+#define IL_HAVE_INTERLOCKED_STORER8_FULL 1
+#endif /* defined(IL_HAVE_INTERLOCKED_MEMORYBARRIER) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_STORER8_FULL) */
+#else /* !defined(ILNATIVE_INT64) */
+/*
+ * Store a signed 64 bit value to a location.
+ */
+static IL_INLINE void _ILInterlockedStoreI8_Full(volatile ILInt64 *dest,
+
ILInt64 value)
+{
ILThreadAtomicStart();
+ *dest = value;
+ ILThreadAtomicEnd();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREI8)
+#define ILInterlockedStoreI8(dest, value) \
+ _ILInterlockedStoreI8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI8) */
+#if !defined(IL_HAVE_INTERLOCKED_STOREI8_ACQUIRE)
+#define ILInterlockedStoreI8_Acquire(dest, value) \
+ _ILInterlockedStoreI8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_STOREI8_RELEASE)
+#define ILInterlockedStoreI8_Release(dest, value) \
+ _ILInterlockedStoreI8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_STOREI8_FULL)
+#define ILInterlockedStoreI8_Full(dest, value) \
+ _ILInterlockedStoreI8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREI8_FULL) */
- retval = *dest;
+/*
+ * Store an unsigned 64 bit value to a location.
+ */
+static IL_INLINE void _ILInterlockedStoreU8_Full(volatile ILUInt64 *dest,
+
ILUInt64 value)
+{
+ ILThreadAtomicStart();
*dest = value;
+ ILThreadAtomicEnd();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STOREU8)
+#define ILInterlockedStoreU8(dest, value) \
+ _ILInterlockedStoreU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU8) */
+#if !defined(IL_HAVE_INTERLOCKED_STOREU8_ACQUIRE)
+#define ILInterlockedStoreU8_Acquire(dest, value) \
+ _ILInterlockedStoreU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_STOREU8_RELEASE)
+#define ILInterlockedStoreU8_Release(dest, value) \
+ _ILInterlockedStoreU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_STOREU8_FULL)
+#define ILInterlockedStoreU8_Full(dest, value) \
+ _ILInterlockedStoreU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_STOREU8_FULL) */
+/*
+ * Store a double precision floatingpoint value to a location.
+ */
+static IL_INLINE void _ILInterlockedStoreR8_Full(volatile ILDouble *dest,
+
ILDouble value)
+{
+ ILThreadAtomicStart();
+ *dest = value;
ILThreadAtomicEnd();
+}
+#if !defined(IL_HAVE_INTERLOCKED_STORER8)
+#define ILInterlockedStoreR8(dest, value) \
+ _ILInterlockedStoreR8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_STORER8) */
+#if !defined(IL_HAVE_INTERLOCKED_STORER8_ACQUIRE)
+#define ILInterlockedStoreR8_Acquire(dest, value) \
+ _ILInterlockedStoreR8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_STORER8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_STORER8_RELEASE)
+#define ILInterlockedStoreR8_Release(dest, value) \
+ _ILInterlockedStoreR8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_STORER8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_STORER8_FULL)
+#define ILInterlockedStoreR8_Full(dest, value) \
+ _ILInterlockedStoreR8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_STORER8_FULL) */
+#endif /* !defined(ILNATIVE_INT64) */
+
+/*
+ * Exchange values
+ */
+
+/*
+ * Map the definitions for equal argument sizes
+ */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI4)
+#define ILInterlockedExchangeU4(dest, value) \
+ ILInterlockedExchangeI4((volatile ILInt32 *)(dest),
(ILInt32)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU4 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_ACQUIRE) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_ACQUIRE)
+#define ILInterlockedExchangeU4_Acquire(dest, value) \
+ ILInterlockedExchangeI4_Acquire((volatile ILInt32 *)(dest),
(ILInt32)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU4_ACQUIRE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_RELEASE) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_RELEASE)
+#define ILInterlockedExchangeU4_Release(dest, value) \
+ ILInterlockedExchangeI4_Release((volatile ILInt32 *)(dest),
(ILInt32)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU4_RELEASE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL)
+#define ILInterlockedExchangeU4_Full(dest, value) \
+ ILInterlockedExchangeI4_Full((volatile ILInt32 *)(dest),
(ILInt32)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU4_FULL 1
+#endif
+
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEU4)
+#define ILInterlockedExchangeI4(dest, value) \
+ ILInterlockedExchangeU4((volatile ILUInt32 *)(dest),
(ILUInt32)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_ACQUIRE) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_ACQUIRE)
+#define ILInterlockedExchangeI4_Acquire(dest, value) \
+ ILInterlockedExchangeU4_Acquire((volatile ILUInt32 *)(dest),
(ILUInt32)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4_ACQUIRE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_RELEASE) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_RELEASE)
+#define ILInterlockedExchangeI4_Release(dest, value) \
+ ILInterlockedExchangeU4_Release((volatile ILUInt32 *)(dest),
(ILUInt32)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4_RELEASE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_FULL)
+#define ILInterlockedExchangeI4_Full(dest, value) \
+ ILInterlockedExchangeU4_Full((volatile ILUInt32 *)(dest),
(ILUInt32)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL 1
+#endif
+
+#if (SIZEOF_FLOAT == 4)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER4) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI4)
+static IL_INLINE ILFloat ILInterlockedExchangeR4(volatile ILFloat *dest,
+
ILFloat value)
+{
+ ILInterlockedConv4 conv4;
+ ILInterlockedConv4 val;
+
+ val.floatValue = value;
+ conv4.int32Value = ILInterlockedExchangeI4((volatile ILInt32 *)dest,
+
val.int32Value);
+ return conv4.floatValue;
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGER4 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL)
+static IL_INLINE ILFloat ILInterlockedExchangeR4_Full(volatile ILFloat *dest,
+
ILFloat value)
+{
+ ILInterlockedConv4 conv4;
+ ILInterlockedConv4 val;
+
+ val.floatValue = value;
+ conv4.int32Value = ILInterlockedExchangeI4_Full((volatile ILInt32
*)dest,
+
val.int32Value);
+ return conv4.floatValue;
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGER4_FULL 1
+#endif
+#endif /* (sizeof(ILFloat) == sizeof(ILInt32)) */
+
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI8)
+#define ILInterlockedExchangeU8(dest, value) \
+ ILInterlockedExchangeI8((volatile ILInt64 *)(dest),
(ILInt64)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU8 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_ACQUIRE) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_ACQUIRE)
+#define ILInterlockedExchangeU8_Acquire(dest, value) \
+ ILInterlockedExchangeI8_Acquire((volatile ILInt64 *)(dest),
(ILInt64)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU8_ACQUIRE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_RELEASE) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_RELEASE)
+#define ILInterlockedExchangeU8_Release(dest, value) \
+ ILInterlockedExchangeI8_Release((volatile ILInt64 *)(dest),
(ILInt64)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU8_RELEASE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_FULL)
+#define ILInterlockedExchangeU8_Full(dest, value) \
+ ILInterlockedExchangeI8_Full((volatile ILInt64 *)(dest),
(ILInt64)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU8_FULL 1
+#endif
+
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEU8)
+#define ILInterlockedExchangeI8(dest, value) \
+ ILInterlockedExchangeU8((volatile ILUInt64 *)(dest),
(ILUInt64)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI8 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_ACQUIRE) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_ACQUIRE)
+#define ILInterlockedExchangeI8_Acquire(dest, value) \
+ ILInterlockedExchangeU8_Acquire((volatile ILUInt64 *)(dest),
(ILUInt64)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI8_ACQUIRE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_RELEASE) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_RELEASE)
+#define ILInterlockedExchangeI8_Release(dest, value) \
+ ILInterlockedExchangeU8_Release((volatile ILUInt64 *)(dest),
(ILUInt64)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI8_RELEASE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_FULL)
+#define ILInterlockedExchangeI8_Full(dest, value) \
+ ILInterlockedExchangeU8_Full((volatile ILUInt64 *)(dest),
(ILUInt64)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI8_FULL 1
+#endif
+#if (SIZEOF_DOUBLE == 8)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER8) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI8)
+static IL_INLINE ILDouble ILInterlockedExchangeR8(volatile ILDouble *dest,
+
ILDouble value)
+{
+ ILInterlockedConv8 conv8;
+ ILInterlockedConv8 val;
+
+ val.doubleValue = value;
+ conv8.int64Value = ILInterlockedExchangeI8((volatile ILInt64 *)dest,
+
val.int64Value);
+ return conv8.doubleValue;
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGER8 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_FULL)
+static IL_INLINE ILDouble ILInterlockedExchangeR8_Full(volatile ILDouble *dest,
+
ILDouble value)
+{
+ ILInterlockedConv8 conv8;
+ ILInterlockedConv8 val;
+
+ val.doubleValue = value;
+ conv8.int64Value = ILInterlockedExchangeI8_Full((volatile ILInt64
*)dest,
+
*(ILInt64 *)valuePtr);
+ return conv8.doubleValue;
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGER8_FULL 1
+#endif
+#endif /* (sizeof(ILDouble) == sizeof(ILInt64)) */
+
+#if defined(IL_NATIVE_INT64)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI8)
+#define ILInterlockedExchangeP(dest, value) \
+ ILInterlockedExchangeI8((volatile ILInt64 *)(dest),
(ILInt64)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEP 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_ACQUIRE) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_ACQUIRE)
+#define ILInterlockedExchangeP_Acquire(dest, value) \
+ ILInterlockedExchangeI8_Acquire((volatile ILInt64 *)(dest),
(ILInt64)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_ACQUIRE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_RELEASE) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_RELEASE)
+#define ILInterlockedExchangeP_Release(dest, value) \
+ ILInterlockedExchangeI8_Release((volatile ILInt64 *)(dest),
(ILInt64)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_RELEASE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_FULL)
+#define ILInterlockedExchangeP_Full(dest, value) \
+ ILInterlockedExchangeI8_Full((volatile ILInt64 *)(dest),
(ILInt64)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_FULL 1
+#endif
+#else /* !defined(IL_NATIVE_INT64) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI4)
+#define ILInterlockedExchangeP(dest, value) \
+ ILInterlockedExchangeI4((volatile ILInt32 *)(dest),
(ILInt32)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEP 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_ACQUIRE) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_ACQUIRE)
+#define ILInterlockedExchangeP_Acquire(dest, value) \
+ ILInterlockedExchangeI4_Acquire((volatile ILInt32 *)(dest),
(ILInt32)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_ACQUIRE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_RELEASE) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_RELEASE)
+#define ILInterlockedExchangeP_Release(dest, value) \
+ ILInterlockedExchangeI4_Release((volatile ILInt32 *)(dest),
(ILInt32)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_RELEASE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL)
+#define ILInterlockedExchangeP_Full(dest, value) \
+ ILInterlockedExchangeI4_Full((volatile ILInt32 *)(dest),
(ILInt32)(value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_FULL 1
+#endif
+#endif /* !defined(IL_NATIVE_INT64) */
+
+/*
+ * Exchange two signed 32 bit integers.
+ */
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGEI4)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_ACQUIRE)
+static IL_INLINE ILInt32 ILInterlockedExchangeI4_Acquire(volatile ILInt32
*dest,
+
ILInt32 value)
+{
+ ILInt32 retval;
+
+ retval = ILInterlockedExchangeI4(dest, value);
+ ILInterlockedMemoryBarrier();
return retval;
}
-#if defined(IL_HAVE_INTERLOCKED_EXCHANGE_FULL)
-#if !defined(IL_HAVE_INTERLOCKED_EXCHANGE_ACQUIRE)
-#define ILInterlockedExchange_Acquire(dest, value) \
- ILInterlockedExchange_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_EXCHANGE_ACQUIRE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGE_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_EXCHANGE_RELEASE)
-#define ILInterlockedExchange_Release(dest, value) \
- ILInterlockedExchange_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_EXCHANGE_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGE_RELEASE) */
-#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGE_FULL) */
-#if !defined(IL_HAVE_INTERLOCKED_EXCHANGE)
-#if defined(IL_HAVE_INTERLOCKED_EXCHANGE_ACQUIRE)
-#define ILInterlockedExchange(dest, value) \
- ILInterlockedExchange_Acquire((dest), (value))
-#define IL_HAVE_INTERLOCKED_EXCHANGE 1
-#elif defined(IL_HAVE_INTERLOCKED_EXCHANGE_RELEASE)
-#define ILInterlockedExchange(dest, value) \
- ILInterlockedExchange_Release((dest), (value))
-#define IL_HAVE_INTERLOCKED_EXCHANGE 1
-#elif defined(IL_HAVE_INTERLOCKED_EXCHANGE_FULL)
-#define ILInterlockedExchange(dest, value) \
- ILInterlockedExchange_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_EXCHANGE 1
-#else /* !defined(IL_HAVE_INTERLOCKED_EXCHANGE_FULL) */
-#define ILInterlockedExchange(dest, value) \
- _ILInterlockedExchange((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGE_FULL) */
-#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGE) */
-#if !defined(IL_HAVE_INTERLOCKED_EXCHANGE_ACQUIRE)
-#define ILInterlockedExchange_Acquire(dest, value) \
- _ILInterlockedExchange((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_RELEASE)
+static IL_INLINE ILInt32 ILInterlockedExchangeI4_Release(volatile ILInt32
*dest,
+
ILInt32 value)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedExchangeI4(dest, value);
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL)
+static IL_INLINE ILInt32 ILInterlockedExchangeI4_Full(volatile ILInt32 *dest,
+
ILInt32 value)
+{
+ ILInt32 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedExchangeI4(dest, value);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGEI4) */
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_ACQUIRE)
+#define ILInterlockedExchangeI4_Acquire(dest, value) \
+ ILInterlockedExchangeI4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4_ACQUIRE 1
#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGE_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_EXCHANGE_RELEASE)
-#define ILInterlockedExchange_Release(dest, value) \
- _ILInterlockedExchange((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGE_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_EXCHANGE_FULL)
-#define ILInterlockedExchange_Full(dest, value) \
- _ILInterlockedExchange((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGE_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_RELEASE)
+#define ILInterlockedExchangeI4_Release(dest, value) \
+ ILInterlockedExchangeI4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4)
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_ACQUIRE)
+#define ILInterlockedExchangeI4(dest, value) \
+ ILInterlockedExchangeI4_Acquire((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4 1
+#elif defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_RELEASE)
+#define ILInterlockedExchangeI4(dest, value) \
+ ILInterlockedExchangeI4_Release((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4 1
+#elif defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL)
+#define ILInterlockedExchangeI4(dest, value) \
+ ILInterlockedExchangeI4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4) */
/*
- * Exchange pointers.
+ * Exchange two unsigned 32 bit integers.
+ */
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGEU4)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_ACQUIRE)
+static IL_INLINE ILUInt32 ILInterlockedExchangeU4_Acquire(volatile ILUInt32
*dest,
+
ILUInt32 value)
+{
+ ILUInt32 retval;
+
+ retval = ILInterlockedExchangeU4(dest, value);
+ ILInterlockedMemoryBarrier();
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGEU4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_RELEASE)
+static IL_INLINE ILUInt32 ILInterlockedExchangeU4_Release(volatile ILUInt32
*dest,
+
ILUInt32 value)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedExchangeU4(dest, value);
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGEU4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_FULL)
+static IL_INLINE ILUInt32 ILInterlockedExchangeU4_Full(volatile ILUInt32 *dest,
+
ILUInt32 value)
+{
+ ILUInt32 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedExchangeU4(dest, value);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGEU4_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGEU4) */
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_ACQUIRE)
+#define ILInterlockedExchangeU4_Acquire(dest, value) \
+ ILInterlockedExchangeU4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_RELEASE)
+#define ILInterlockedExchangeU4_Release(dest, value) \
+ ILInterlockedExchangeU4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4)
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_ACQUIRE)
+#define ILInterlockedExchangeU4(dest, value) \
+ ILInterlockedExchangeU4_Acquire((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU4 1
+#elif defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_RELEASE)
+#define ILInterlockedExchangeU4(dest, value) \
+ ILInterlockedExchangeU4_Release((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU4 1
+#elif defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_FULL)
+#define ILInterlockedExchangeU4(dest, value) \
+ ILInterlockedExchangeU4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU4 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4) */
+
+/*
+ * Exchange two single precision floatingpoint integers.
+ */
+
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGER4)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_ACQUIRE)
+static IL_INLINE ILFloat ILInterlockedExchangeR4_Acquire(volatile ILFloat
*dest,
+
ILFloat value)
+{
+ ILFloat retval;
+
+ retval = ILInterlockedExchangeR4(dest, value);
+ ILInterlockedMemoryBarrier();
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGER4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_RELEASE)
+static IL_INLINE ILFloat ILInterlockedExchangeR4_Release(volatile ILFloat
*dest,
+
ILFloat value)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedExchangeR4(dest, value);
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGER4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_FULL)
+static IL_INLINE ILFloat ILInterlockedExchangeR4_Full(volatile ILFloat *dest,
+
ILFloat value)
+{
+ ILFloat retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedExchangeR4(dest, value);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGER4_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGER4) */
+
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGER4_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_ACQUIRE)
+#define ILInterlockedExchangeR4_Acquire(dest, value) \
+ ILInterlockedExchangeR4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGER4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_RELEASE)
+#define ILInterlockedExchangeR4_Release(dest, value) \
+ ILInterlockedExchangeR4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGER4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGER4_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER4)
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGER4_ACQUIRE)
+#define ILInterlockedExchangeR4(dest, value) \
+ ILInterlockedExchangeR4_Acquire((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGER4 1
+#elif defined(IL_HAVE_INTERLOCKED_EXCHANGER4_RELEASE)
+#define ILInterlockedExchangeR4(dest, value) \
+ ILInterlockedExchangeR4_Release((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGER4 1
+#elif defined(IL_HAVE_INTERLOCKED_EXCHANGER4_FULL)
+#define ILInterlockedExchangeR4(dest, value) \
+ ILInterlockedExchangeR4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGER4 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER4) */
+
+/*
+ * Exchange two signed 64 bit integers.
*/
-static IL_INLINE void *_ILInterlockedExchangePointers(void * volatile *dest,
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGEI8)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_ACQUIRE)
+static IL_INLINE ILInt64 ILInterlockedExchangeI8_Acquire(volatile ILInt64
*dest,
+
ILInt64 value)
+{
+ ILInt64 retval;
+
+ retval = ILInterlockedExchangeI8(dest, value);
+ ILInterlockedMemoryBarrier();
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGEI8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_RELEASE)
+static IL_INLINE ILInt64 ILInterlockedExchangeI8_Release(volatile ILInt64
*dest,
+
ILInt64 value)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedExchangeI8(dest, value);
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGEI8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_FULL)
+static IL_INLINE ILInt64 ILInterlockedExchangeI8_Full(volatile ILInt64 *dest,
+
ILInt64 value)
+{
+ ILInt64 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedExchangeI8(dest, value);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGEI8_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGEI8) */
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_ACQUIRE)
+#define ILInterlockedExchangeI8_Acquire(dest, value) \
+ ILInterlockedExchangeI8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_RELEASE)
+#define ILInterlockedExchangeI8_Release(dest, value) \
+ ILInterlockedExchangeI8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8)
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_ACQUIRE)
+#define ILInterlockedExchangeI8(dest, value) \
+ ILInterlockedExchangeI8_Acquire((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI8 1
+#elif defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_RELEASE)
+#define ILInterlockedExchangeI8(dest, value) \
+ ILInterlockedExchangeI8_Release((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI8 1
+#elif defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_FULL)
+#define ILInterlockedExchangeI8(dest, value) \
+ ILInterlockedExchangeI8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEI8 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8) */
+
+/*
+ * Exchange two unsigned 64 bit integers.
+ */
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGEU8)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_ACQUIRE)
+static IL_INLINE ILUInt64 ILInterlockedExchangeU8_Acquire(volatile ILUInt64
*dest,
+
ILUInt64 value)
+{
+ ILUInt64 retval;
+
+ retval = ILInterlockedExchangeU8(dest, value);
+ ILInterlockedMemoryBarrier();
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGEU8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_RELEASE)
+static IL_INLINE ILUInt64 ILInterlockedExchangeU8_Release(volatile ILUInt64
*dest,
+
ILUInt64 value)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedExchangeU8(dest, value);
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGEU8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_FULL)
+static IL_INLINE ILUInt64 ILInterlockedExchangeU8_Full(volatile ILUInt64 *dest,
+
ILUInt64 value)
+{
+ ILUInt64 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedExchangeU8(dest, value);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGEU8_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGEU8) */
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_ACQUIRE)
+#define ILInterlockedExchangeU8_Acquire(dest, value) \
+ ILInterlockedExchangeU8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_RELEASE)
+#define ILInterlockedExchangeU8_Release(dest, value) \
+ ILInterlockedExchangeU8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8)
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_ACQUIRE)
+#define ILInterlockedExchangeU8(dest, value) \
+ ILInterlockedExchangeU8_Acquire((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU8 1
+#elif defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_RELEASE)
+#define ILInterlockedExchangeU8(dest, value) \
+ ILInterlockedExchangeU8_Release((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU8 1
+#elif defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_FULL)
+#define ILInterlockedExchangeU8(dest, value) \
+ ILInterlockedExchangeU8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEU8 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8) */
+
+/*
+ * Exchange two double precision floatingpoint values.
+ */
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGER8)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_ACQUIRE)
+static IL_INLINE ILDouble ILInterlockedExchangeR8_Acquire(volatile ILDouble
*dest,
+
ILDouble value)
+{
+ ILDouble retval;
+
+ retval = ILInterlockedExchangeR8(dest, value);
+ ILInterlockedMemoryBarrier();
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGER8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_RELEASE)
+static IL_INLINE ILDouble ILInterlockedExchangeR8_Release(volatile ILDouble
*dest,
+
ILDouble value)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedExchangeR8(dest, value);
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGER8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_FULL)
+static IL_INLINE ILDouble ILInterlockedExchangeR8_Full(volatile ILDouble *dest,
+
ILDouble value)
+{
+ ILDouble retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedExchangeR8(dest, value);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGER8_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGER8) */
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGER8_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_ACQUIRE)
+#define ILInterlockedExchangeR8_Acquire(dest, value) \
+ ILInterlockedExchangeR8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGER8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_RELEASE)
+#define ILInterlockedExchangeR8_Release(dest, value) \
+ ILInterlockedExchangeR8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGER8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGER8_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER8)
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGER8_ACQUIRE)
+#define ILInterlockedExchangeR8(dest, value) \
+ ILInterlockedExchangeRU8_Acquire((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGER8 1
+#elif defined(IL_HAVE_INTERLOCKED_EXCHANGER8_RELEASE)
+#define ILInterlockedExchangeR8(dest, value) \
+ ILInterlockedExchangeR8_Release((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGER8 1
+#elif defined(IL_HAVE_INTERLOCKED_EXCHANGER8_FULL)
+#define ILInterlockedExchangeR8(dest, value) \
+ ILInterlockedExchangeR8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGER8 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER8) */
+
+/*
+ * Exchange two pointers.
+ */
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGEP)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_ACQUIRE)
+static IL_INLINE void *ILInterlockedExchangeP_Acquire(void * volatile *dest,
void *value)
{
void *retval;
-
- ILThreadAtomicStart();
-
- retval = *dest;
- *dest = value;
-
- ILThreadAtomicEnd();
-
+
+ retval = ILInterlockedExchangeP(dest, value);
+ ILInterlockedMemoryBarrier();
return retval;
}
-#if defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_FULL)
-#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_ACQUIRE)
-#define ILInterlockedExchangePointers_Acquire(dest, value) \
- ILInterlockedExchangePointers_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_ACQUIRE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_RELEASE)
-#define ILInterlockedExchangePointers_Release(dest, value) \
- ILInterlockedExchangePointers_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_RELEASE) */
-#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_FULL) */
-#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS)
-#if defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_ACQUIRE)
-#define ILInterlockedExchangePointers(dest, value) \
- ILInterlockedExchangePointers_Acquire((dest), (value))
-#define IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS 1
-#elif defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_RELEASE)
-#define ILInterlockedExchangePointers(dest, value) \
- ILInterlockedExchangePointers_Release((dest), (value))
-#define IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS 1
-#elif defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_FULL)
-#define ILInterlockedExchangePointers(dest, value) \
- ILInterlockedExchangePointers_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_EXCHANGE 1
-#else /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_FULL) */
-#define ILInterlockedExchangePointers(dest, value) \
- _ILInterlockedExchangePointers((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_FULL) */
-#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS) */
-#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_ACQUIRE)
-#define ILInterlockedExchangePointers_Acquire(dest, value) \
- _ILInterlockedExchangePointers((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_RELEASE)
-#define ILInterlockedExchangePointers_Release(dest, value) \
- _ILInterlockedExchangePointers((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_FULL)
-#define ILInterlockedExchangePointers_Full(dest, value) \
- _ILInterlockedExchangePointers((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGE_FULL) */
-
-/*
- * Compare and exchange two 32bit integers.
- */
-static IL_INLINE ILInt32 _ILInterlockedCompareAndExchange(volatile ILInt32
*dest,
-
ILInt32 value,
-
ILInt32 comparand)
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_RELEASE)
+static IL_INLINE void *ILInterlockedExchangeP_Release(void * volatile *dest,
+
void *value)
{
- ILInt32 retval;
-
- ILThreadAtomicStart();
-
- retval = *dest;
-
- if (retval == comparand)
- {
- *dest = value;
- }
-
- ILThreadAtomicEnd();
-
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedExchangeP(dest, value);
+}
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_FULL)
+static IL_INLINE void *ILInterlockedExchangeP_Full(void * volatile *dest,
+
void *value)
+{
+ void *retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedExchangeP(dest, value);
+ ILInterlockedMemoryBarrier();
+
return retval;
}
-#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_FULL)
-#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_ACQUIRE)
-#define ILInterlockedCompareAndExchange_Acquire(dest, value, comparand) \
- ILInterlockedCompareAndExchange_Full((dest), (value),
(comparand))
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_ACQUIRE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_RELEASE)
-#define ILInterlockedCompareAndExchange_Release(dest, value, comparand) \
- ILInterlockedCompareAndExchange_Full((dest), (value),
(comparand))
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_RELEASE) */
-#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_FULL) */
-#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE)
-#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_ACQUIRE)
-#define ILInterlockedCompareAndExchange(dest, value, comparand) \
- ILInterlockedCompareAndExchange_Acquire((dest), (value),
(comparand))
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE 1
-#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_RELEASE)
-#define ILInterlockedCompareAndExchange(dest, value, comparand) \
- ILInterlockedCompareAndExchange_Release((dest), (value),
(comparand))
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE 1
-#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_FULL)
-#define ILInterlockedCompareAndExchange(dest, value, comparand) \
- ILInterlockedCompareAndExchange_Full((dest), (value),
(comparand))
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE 1
-#else /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_FULL) */
-#define ILInterlockedCompareAndExchange(dest, value, comparand) \
- _ILInterlockedCompareAndExchange((dest), (value), (comparand))
-#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_FULL) */
-#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE) */
-#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_ACQUIRE)
-#define ILInterlockedCompareAndExchange_Acquire(dest, value, comparand) \
- _ILInterlockedCompareAndExchange((dest), (value), (comparand))
-#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_RELEASE)
-#define ILInterlockedCompareAndExchange_Release(dest, value, comparand) \
- _ILInterlockedCompareAndExchange((dest), (value), (comparand))
-#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_FULL)
-#define ILInterlockedCompareAndExchange_Full(dest, value, comparand) \
- _ILInterlockedCompareAndExchange((dest), (value), (comparand))
-#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_FULL) */
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGEP) */
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGEP_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_ACQUIRE)
+#define ILInterlockedExchangeP_Acquire(dest, value) \
+ ILInterlockedExchangeP_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_RELEASE)
+#define ILInterlockedExchangeP_Release(dest, value) \
+ ILInterlockedExchangeP_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_EXCHANGEP_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP)
+#if defined(IL_HAVE_INTERLOCKED_EXCHANGEP_ACQUIRE)
+#define ILInterlockedExchangeP(dest, value) \
+ ILInterlockedExchangeP_Acquire((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEP 1
+#elif defined(IL_HAVE_INTERLOCKED_EXCHANGEP_RELEASE)
+#define ILInterlockedExchangeP(dest, value) \
+ ILInterlockedExchangeP_Release((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEP 1
+#elif defined(IL_HAVE_INTERLOCKED_EXCHANGEP_FULL)
+#define ILInterlockedExchangeP(dest, value) \
+ ILInterlockedExchangeP_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_EXCHANGEP 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEP) */
/*
- * Compare and exchange two pointers.
+ * Exchange pointers.
*/
-static IL_INLINE void *_ILInterlockedCompareAndExchangePointers(void *
volatile *dest,
-
void *value,
-
void *comparand)
+static IL_INLINE void *_ILInterlockedExchangeP_Full(void * volatile *dest,
+
void *value)
{
void *retval;
ILThreadAtomicStart();
- retval = (void *)*dest;
-
- if (retval == comparand)
- {
- *dest = value;
- }
+ retval = *dest;
+ *dest = value;
ILThreadAtomicEnd();
return retval;
}
-#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_FULL)
-#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_ACQUIRE)
-#define ILInterlockedCompareAndExchangePointers_Acquire(dest, value,
comparand) \
- ILInterlockedCompareAndExchangePointers_Full((dest), (value),
(comparand))
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_ACQUIRE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_RELEASE)
-#define ILInterlockedCompareAndExchangePointers_Release(dest, value,
comparand) \
- ILInterlockedCompareAndExchangePointers_Full((dest), (value),
(comparand))
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_RELEASE) */
-#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_FULL) */
-#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS)
-#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_ACQUIRE)
-#define ILInterlockedCompareAndExchangePointers(dest, value, comparand) \
- ILInterlockedCompareAndExchangePointers_Acquire((dest),
(value), (comparand))
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS 1
-#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_RELEASE)
-#define ILInterlockedCompareAndExchangePointers(dest, value, comparand) \
- ILInterlockedCompareAndExchangePointers_Release((dest),
(value), (comparand))
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS 1
-#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_FULL)
-#define ILInterlockedCompareAndExchangePointers(dest, value, comparand) \
- ILInterlockedCompareAndExchangePointers_Full((dest), (value),
(comparand))
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS 1
-#else /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_FULL) */
-#define ILInterlockedCompareAndExchangePointers(dest, value, comparand) \
- _ILInterlockedCompareAndExchangePointers((dest), (value),
(comparand))
-#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_FULL) */
-#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS) */
-#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_ACQUIRE)
-#define ILInterlockedCompareAndExchangePointers_Acquire(dest, value,
comparand) \
- _ILInterlockedCompareAndExchangePointers((dest), (value),
(comparand))
-#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_RELEASE)
-#define ILInterlockedCompareAndExchangePointers_Release(dest, value,
comparand) \
- _ILInterlockedCompareAndExchangePointers((dest), (value),
(comparand))
-#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_FULL)
-#define ILInterlockedCompareAndExchangePointers_Full(dest, value, comparand) \
- _ILInterlockedCompareAndExchangePointers((dest), (value),
(comparand))
-#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_FULL) */
-
-/*
- * Add the two 32bit integers *dest and value and store the result at *dest.
- */
-static IL_INLINE ILInt32 _ILInterlockedAdd(volatile ILInt32 *dest,
-
ILInt32 value)
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP)
+#define ILInterlockedExchangeP(dest, value) \
+ _ILInterlockedExchangeP_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEP) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_ACQUIRE)
+#define ILInterlockedExchangeP_Acquire(dest, value) \
+ _ILInterlockedExchangeP_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_RELEASE)
+#define ILInterlockedExchangeP_Release(dest, value) \
+ _ILInterlockedExchangeP_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_FULL)
+#define ILInterlockedExchangeP_Full(dest, value) \
+ _ILInterlockedExchangeP_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEP_FULL) */
+
+/*
+ * Compare and exchange two values
+ */
+
+/*
+ * Map the definitions for equal argument sizes
+ */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4)
+#define ILInterlockedCompareAndExchangeU4(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI4((volatile ILInt32 *)(dest),
(ILInt32)(value), (ILInt32)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_ACQUIRE) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_ACQUIRE)
+#define ILInterlockedCompareAndExchangeU4_Acquire(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI4_Acquire((volatile ILInt32
*)(dest), (ILInt32)(value), (ILInt32)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_ACQUIRE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_RELEASE) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_RELEASE)
+#define ILInterlockedCompareAndExchangeU4_Release(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI4_Release((volatile ILInt32
*)(dest), (ILInt32)(value), (ILInt32)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_RELEASE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL)
+#define ILInterlockedCompareAndExchangeU4_Full(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI4_Full((volatile ILInt32
*)(dest), (ILInt32)(value), (ILInt32)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_FULL 1
+#endif
+
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4)
+#define ILInterlockedCompareAndExchangeI4(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU4((volatile ILUInt32 *)(dest),
(ILUInt32)(value), (ILUInt32)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_ACQUIRE) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_ACQUIRE)
+#define ILInterlockedCompareAndExchangeI4_Acquire(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU4_Acquire((volatile ILUInt32
*)(dest), (ILUInt32)(value), (ILUInt32)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_ACQUIRE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_RELEASE) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_RELEASE)
+#define ILInterlockedCompareAndExchangeI4_Release(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU4_Release((volatile ILUInt32
*)(dest), (ILUInt32)(value), (ILUInt32)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_RELEASE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_FULL)
+#define ILInterlockedCompareAndExchangeI4_Full(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU4_Full((volatile ILUInt32
*)(dest), (ILUInt32)(value), (ILUInt32)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL 1
+#endif
+
+#if (SIZEOF_FLOAT == 4)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4)
+static IL_INLINE ILFloat ILInterlockedCompareAndExchangeR4(volatile ILFloat
*dest,
+
ILFloat value,
+
ILFloat comparand)
{
- ILInt32 retval;
+ ILInterlockedConv4 conv4;
+ ILInterlockedConv4 val;
+ ILInterlockedConv4 cmp;
- ILThreadAtomicStart();
+ val.floatValue = value;
+ cmp.floatValue = comparand;
+ conv4.int32Value = ILInterlockedCompareAndExchangeI4((volatile ILInt32
*)dest,
+
val.int32Value,
+
cmp.int32Value);
+ return conv4.floatValue;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL)
+static IL_INLINE ILFloat ILInterlockedCompareAndExchangeR4_Full(volatile
ILFloat *dest,
+
ILFloat value,
+
ILFloat comparand)
+{
+ ILInterlockedConv4 conv4;
+ ILInterlockedConv4 val;
+ ILInterlockedConv4 cmp;
- retval = *dest + value;
- *dest = retval;
+ val.floatValue = value;
+ cmp.floatValue = comparand;
+ conv4.int32Value = ILInterlockedCompareAndExchangeI4_Full((volatile
ILInt32 *)dest,
+
val.int32Value,
+
cmp.int32Value);
+ return conv4.floatValue;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_FULL 1
+#endif
+#endif /* (sizeof(ILFloat) == sizeof(ILInt32)) */
- ILThreadAtomicEnd();
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8)
+#define ILInterlockedCompareAndExchangeU8(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI8((volatile ILInt64 *)(dest),
(ILInt64)(value), (ILInt64)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_ACQUIRE) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_ACQUIRE)
+#define ILInterlockedCompareAndExchangeU8_Acquire(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI8_Acquire((volatile ILInt64
*)(dest), (ILInt64)(value), (ILInt64)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_ACQUIRE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_RELEASE) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_RELEASE)
+#define ILInterlockedCompareAndExchangeU8_Release(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI8_Release((volatile ILInt64
*)(dest), (ILInt64)(value), (ILInt64)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_RELEASE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL)
+#define ILInterlockedCompareAndExchangeU8_Full(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI8_Full((volatile ILInt64
*)(dest), (ILInt64)(value), (ILInt64)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_FULL 1
+#endif
- return retval;
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8)
+#define ILInterlockedCompareAndExchangeI8(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU8((volatile ILUInt64 *)(dest),
(ILUInt64)(value), (ILUInt64)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_ACQUIRE) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_ACQUIRE)
+#define ILInterlockedCompareAndExchangeI8_Acquire(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU8_Acquire((volatile ILUInt64
*)(dest), (ILUInt64)(value), (ILUInt64)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_ACQUIRE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_RELEASE) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_RELEASE)
+#define ILInterlockedCompareAndExchangeI8_Release(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU8_Release((volatile ILUInt64
*)(dest), (ILUInt64)(value), (ILUInt64)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_RELEASE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_FULL)
+#define ILInterlockedCompareAndExchangeI8_Full(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU8_Full((volatile ILUInt64
*)(dest), (ILUInt64)(value), (ILUInt64)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL 1
+#endif
+
+#if (SIZEOF_DOUBLE == 8)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8)
+static IL_INLINE ILDouble ILInterlockedCompareAndExchangeR8(volatile ILDouble
*dest,
+
ILDouble value,
+
ILDouble comparand)
+{
+ ILInterlockedConv8 conv8;
+ ILInterlockedConv8 val;
+ ILInterlockedConv8 cmp;
+
+ val.doubleValue = value;
+ cmp.doubleValue = comparand;
+ conv8.int64Value = ILInterlockedCompareAndExchangeI8((volatile ILInt64
*)dest,
+
val.int64Value,
+
cmp.int64Value);
+ return conv8.doubleValue;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL)
+static IL_INLINE ILDouble ILInterlockedCompareAndExchangeR8_Full(volatile
ILDouble *dest,
+
ILDouble value,
+
ILDouble comparand)
+{
+ ILInterlockedConv8 conv8;
+ ILInterlockedConv8 val;
+ ILInterlockedConv8 cmp;
+
+ val.doubleValue = value;
+ cmp.doubleValue = comparand;
+ conv8.int64Value = ILInterlockedCompareAndExchangeI8_Full((volatile
ILInt64 *)dest,
+
val.int64Value,
+
cmp.int64Value);
+ return conv8.doubleValue;
}
-#if defined(IL_HAVE_INTERLOCKED_ADD_FULL)
-#if !defined(IL_HAVE_INTERLOCKED_ADD_ACQUIRE)
-#define ILInterlockedAdd_Acquire(dest, value) \
- ILInterlockedAdd_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_ADD_ACQUIRE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_ADD_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_ADD_RELEASE)
-#define ILInterlockedAdd_Release(dest, value) \
- ILInterlockedAdd_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_ADD_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_ADD_RELEASE) */
-#endif /* defined(IL_HAVE_INTERLOCKED_ADD_FULL) */
-#if !defined(IL_HAVE_INTERLOCKED_ADD)
-#if defined(IL_HAVE_INTERLOCKED_ADD_ACQUIRE)
-#define ILInterlockedAdd(dest, value) \
- ILInterlockedAdd_Acquire((dest), (value))
-#define IL_HAVE_INTERLOCKED_ADD 1
-#elif defined(IL_HAVE_INTERLOCKED_ADD_RELEASE)
-#define ILInterlockedAdd(dest, value) \
- ILInterlockedAdd_Release((dest), (value))
-#define IL_HAVE_INTERLOCKED_ADD 1
-#elif defined(IL_HAVE_INTERLOCKED_ADD_FULL)
-#define ILInterlockedAdd(dest, value) \
- ILInterlockedAdd_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_ADD 1
-#endif /* defined(IL_HAVE_INTERLOCKED_ADD_FULL) */
-#endif /* !defined(IL_HAVE_INTERLOCKED_ADD) */
-#if !defined(IL_HAVE_INTERLOCKED_ADD) && \
- defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE)
-static IL_INLINE ILInt32 ILInterlockedAdd(volatile ILInt32 *dest,
-
ILInt32 value)
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_FULL 1
+#endif
+#endif /* (sizeof(ILDouble) == sizeof(ILInt64)) */
+
+#if defined(IL_NATIVE_INT64)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8)
+#define ILInterlockedCompareAndExchangeP(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI8((volatile ILInt64 *)(dest),
(ILInt64)(value), (ILInt64)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_ACQUIRE) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_ACQUIRE)
+#define ILInterlockedCompareAndExchangeP_Acquire(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI8_Acquire((volatile ILInt64
*)(dest), (ILInt64)(value), (ILInt64)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_ACQUIRE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_RELEASE) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_RELEASE)
+#define ILInterlockedCompareAndExchangeP_Release(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI8_Release((volatile ILInt64
*)(dest), (ILInt64)(value), (ILInt64)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_RELEASE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL)
+#define ILInterlockedCompareAndExchangeP_Full(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI8_Full((volatile ILInt64
*)(dest), (ILInt64)(value), (ILInt64)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL 1
+#endif
+#else /* !defined(IL_NATIVE_INT64) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4)
+#define ILInterlockedCompareAndExchangeP(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI4((volatile ILInt32 *)(dest),
(ILInt32)(value), (ILInt32)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_ACQUIRE) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_ACQUIRE)
+#define ILInterlockedCompareAndExchangeP_Acquire(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI4_Acquire((volatile ILInt32
*)(dest), (ILInt32)(value), (ILInt32)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_ACQUIRE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_RELEASE) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_RELEASE)
+#define ILInterlockedCompareAndExchangeP_Release(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI4_Release((volatile ILInt32
*)(dest), (ILInt32)(value), (ILInt32)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_RELEASE 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL)
+#define ILInterlockedCompareAndExchangeP_Full(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI4_Full((volatile ILInt32
*)(dest), (ILInt32)(value), (ILInt32)(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL 1
+#endif
+#endif /* !defined(IL_NATIVE_INT64) */
+
+/*
+ * Support alternative implementations with only picking up real native
+ * implementationd of ILInterlockedCompareAndExchange functions.
+ */
+#if !defined(IL_HAVE_INTERLOCKED_ADDI4) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4)
+static IL_INLINE ILInt32 ILInterlockedAddI4(volatile ILInt32 *dest,
+
ILInt32 value)
{
ILInt32 oldval;
ILInt32 retval;
do
{
- oldval = ILInterlockedLoad(dest);
+ oldval = ILInterlockedLoadI4(dest);
retval = oldval + value;
- } while(ILInterlockedCompareAndExchange(dest, retval, oldval) !=
oldVal);
+ } while(ILInterlockedCompareAndExchangeI4(dest, retval, oldval) !=
oldval);
return retval;
}
-#define IL_HAVE_INTERLOCKED_ADD 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_ADD) */
-#if !defined(IL_HAVE_INTERLOCKED_ADD_ACQUIRE) && \
- defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_ACQUIRE)
-static IL_INLINE ILInt32 ILInterlockedAdd_Acquire(volatile ILInt32 *dest,
-
ILInt32 value)
+#define IL_HAVE_INTERLOCKED_ADDI4 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_ADDI4_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL)
+static IL_INLINE ILInt32 ILInterlockedAddI4_Full(volatile ILInt32 *dest,
+
ILInt32 value)
{
ILInt32 oldval;
ILInt32 retval;
do
{
- oldval = ILInterlockedLoad(dest);
+ oldval = ILInterlockedLoadI4(dest);
retval = oldval + value;
- } while(ILInterlockedCompareAndExchange_Acquire(dest, retval, oldval)
!= oldval);
+ } while(ILInterlockedCompareAndExchangeI4_Full(dest, retval, oldval) !=
oldval);
return retval;
}
-#define IL_HAVE_INTERLOCKED_ADD_ACQUIRE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_ADD_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_ADD_RELEASE) && \
- defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_RELEASE)
-static IL_INLINE ILInt32 ILInterlockedAdd_Release(volatile ILInt32 *dest,
-
ILInt32 value)
+#define IL_HAVE_INTERLOCKED_ADDI4_FULL 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_ADDI8) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8)
+static IL_INLINE ILInt64 ILInterlockedAddI8(volatile ILInt64 *dest,
+
ILInt64 value)
{
- ILInt32 oldval;
- ILInt32 retval;
+ ILInt64 oldval;
+ ILInt64 retval;
do
{
- oldval = ILInterlockedLoad(dest);
+ oldval = ILInterlockedLoadI8(dest);
retval = oldval + value;
- } while(ILInterlockedCompareAndExchange_Release(dest, retval, oldval)
!= oldval);
+ } while(ILInterlockedCompareAndExchangeI8(dest, retval, oldval) !=
oldval);
return retval;
}
-#define IL_HAVE_INTERLOCKED_ADD_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_ADD_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_ADD_FULL) && \
- defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_FULL)
-static IL_INLINE ILInt32 ILInterlockedAdd_Full(volatile ILInt32 *dest,
-
ILInt32 value)
+#define IL_HAVE_INTERLOCKED_ADDI8 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_ADDI8_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL)
+static IL_INLINE ILInt64 ILInterlockedAddI8_Full(volatile ILInt64 *dest,
+
ILInt64 value)
{
- ILInt32 oldval;
- ILInt32 retval;
+ ILInt64 oldval;
+ ILInt64 retval;
do
{
- oldval = ILInterlockedLoad(dest);
+ oldval = ILInterlockedLoadI8(dest);
retval = oldval + value;
- } while(ILInterlockedCompareAndExchange_Full(dest, retval, oldval) !=
oldval);
+ } while(ILInterlockedCompareAndExchangeI8_Full(dest, retval, oldval) !=
oldval);
return retval;
}
-#define IL_HAVE_INTERLOCKED_ADD_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_ADD_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_ADD)
-#define ILInterlockedAdd(dest, value) _ILInterlockedAdd((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_ADD) */
-#if !defined(IL_HAVE_INTERLOCKED_ADD_ACQUIRE)
-#define ILInterlockedAdd_Acquire(dest, value) _ILInterlockedAdd((dest),
(value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_ADD_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_ADD_RELEASE)
-#define ILInterlockedAdd_Release(dest, value) _ILInterlockedAdd((dest),
(value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_ADD_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_ADD_FULL)
-#define ILInterlockedAdd_Full(dest, value) _ILInterlockedAdd((dest),
(value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_ADD_FULL) */
-
-/*
- * Subtract value from *dest and store the result at *dest.
- */
-#define _ILInterlockedSub(dest, value) _ILInterlockedAdd((dest), -(value))
-#if defined(IL_HAVE_INTERLOCKED_SUB_FULL)
-#if !defined(IL_HAVE_INTERLOCKED_SUB_ACQUIRE)
-#define ILInterlockedSub_Acquire(dest, value) \
- ILInterlockedSub_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_SUB_ACQUIRE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_ADD_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_SUB_RELEASE)
-#define ILInterlockedSub_Release(dest, value) \
- ILInterlockedSub_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_SUB_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_SUB_RELEASE) */
-#endif /* defined(IL_HAVE_INTERLOCKED_SUB_FULL) */
-#if !defined(IL_HAVE_INTERLOCKED_SUB) && \
- defined(IL_HAVE_INTERLOCKED_ADD)
-#define ILInterlockedSub(dest, value) ILInterlockedAdd((dest), -(value))
-#define IL_HAVE_INTERLOCKED_SUB 1
-#endif
-#if !defined(IL_HAVE_INTERLOCKED_SUB_ACQUIRE) && \
- defined(IL_HAVE_INTERLOCKED_ADD_ACQUIRE)
-#define ILInterlockedSub_Acquire(dest, value) \
- ILInterlockedAdd_Acquire((dest), -(value))
-#define IL_HAVE_INTERLOCKED_SUB_ACQUIRE 1
-#endif
-#if !defined(IL_HAVE_INTERLOCKED_SUB_RELEASE) && \
- defined(IL_HAVE_INTERLOCKED_ADD_RELEASE)
-#define ILInterlockedSub_Release(dest, value) \
- ILInterlockedAdd_Release((dest), -(value))
-#define IL_HAVE_INTERLOCKED_SUB_RELEASE 1
-#endif
-#if !defined(IL_HAVE_INTERLOCKED_SUB_FULL) && \
- defined(IL_HAVE_INTERLOCKED_ADD_FULL)
-#define ILInterlockedSub_Full(dest, value) \
- ILInterlockedAdd_Full((dest), -(value))
-#define IL_HAVE_INTERLOCKED_SUB_FULL 1
-#endif
-#if !defined(IL_HAVE_INTERLOCKED_SUB)
-#define ILInterlockedSub(dest, value) _ILInterlockedSub((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_SUB) */
-#if !defined(IL_HAVE_INTERLOCKED_SUB_ACQUIRE)
-#define ILInterlockedSub_Acquire(dest, value) \
- _ILInterlockedSub((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_SUB_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_SUB_RELEASE)
-#define ILInterlockedSub_Release(dest, value) \
- _ILInterlockedSub((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_SUB_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_SUB_FULL)
-#define ILInterlockedSub_Full(dest, value) _ILInterlockedSub((dest),
(value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_SUB_FULL) */
-
-/*
- * Increment a 32bit integer.
- */
-#define _ILInterlockedIncrement(dest) _ILInterlockedAdd((dest), 1)
-#if defined(IL_HAVE_INTERLOCKED_INCREMENT_FULL)
-#if !defined(IL_HAVE_INTERLOCKED_INCREMENT_ACQUIRE)
-#define ILInterlockedIncrement_Acquire(dest) \
- ILInterlockedIncrement_Full((dest))
-#define IL_HAVE_INTERLOCKED_INCREMENT_ACQUIRE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENT_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_INCREMENT_RELEASE)
-#define ILInterlockedIncrement_Release(dest) \
- ILInterlockedIncrement_Full((dest))
-#define IL_HAVE_INTERLOCKED_INCREMENT_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENT_RELEASE) */
-#endif /* defined(IL_HAVE_INTERLOCKED_INCREMENT_FULL) */
-#if !defined(IL_HAVE_INTERLOCKED_INCREMENT) && \
- defined(IL_HAVE_INTERLOCKED_ADD)
-#define ILInterlockedIncrement(dest) ILInterlockedAdd((dest), 1)
-#define IL_HAVE_INTERLOCKED_INCREMENT 1
-#endif
-#if !defined(IL_HAVE_INTERLOCKED_INCREMENT_ACQUIRE) && \
- defined(IL_HAVE_INTERLOCKED_ADD_ACQUIRE)
-#define ILInterlockedIncrement_Acquire(dest) \
- ILInterlockedAdd_Acquire((dest), 1)
-#define IL_HAVE_INTERLOCKED_INCREMENT_ACQUIRE 1
-#endif
-#if !defined(IL_HAVE_INTERLOCKED_INCREMENT_RELEASE) && \
- defined(IL_HAVE_INTERLOCKED_ADD_RELEASE)
-#define ILInterlockedIncrement_Release(dest) \
- ILInterlockedAdd_Release((dest), 1)
-#define IL_HAVE_INTERLOCKED_INCREMENT_RELEASE 1
-#endif
-#if !defined(IL_HAVE_INTERLOCKED_INCREMENT_FULL) && \
- defined(IL_HAVE_INTERLOCKED_ADD_FULL)
-#define ILInterlockedIncrement_Full(dest) \
- ILInterlockedAdd_Full((dest), 1)
-#define IL_HAVE_INTERLOCKED_INCREMENT_FULL 1
-#endif
-#if !defined(IL_HAVE_INTERLOCKED_INCREMENT)
-#define ILInterlockedIncrement(dest) _ILInterlockedIncrement((dest))
-#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENT) */
-#if !defined(IL_HAVE_INTERLOCKED_INCREMENT_ACQUIRE)
-#define ILInterlockedIncrement_Acquire(dest) _ILInterlockedIncrement((dest))
-#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENT_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_INCREMENT_RELEASE)
-#define ILInterlockedIncrement_Release(dest) _ILInterlockedIncrement((dest))
-#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENT_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_INCREMENT_FULL)
-#define ILInterlockedIncrement_Full(dest) _ILInterlockedIncrement((dest))
-#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENT_FULL) */
-
-/*
- * Decrement a 32bit integer.
- */
-#define _ILInterlockedDecrement(dest) _ILInterlockedSub((dest), 1)
-#if defined(IL_HAVE_INTERLOCKED_DECREMENT_FULL)
-#if !defined(IL_HAVE_INTERLOCKED_DECREMENT_ACQUIRE)
-#define ILInterlockedDecrement_Acquire(dest) \
- ILInterlockedDecrement_Full((dest))
-#define IL_HAVE_INTERLOCKED_DECREMENT_ACQUIRE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENT_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_DECREMENT_RELEASE)
-#define ILInterlockedDecrement_Release(dest) \
- ILInterlockedDecrement_Full((dest))
-#define IL_HAVE_INTERLOCKED_DECREMENT_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENT_RELEASE) */
-#endif /* defined(IL_HAVE_INTERLOCKED_DECREMENT_FULL) */
-#if !defined(IL_HAVE_INTERLOCKED_DECREMENT) && \
- defined(IL_HAVE_INTERLOCKED_SUB)
-#define ILInterlockedDecrement(dest) ILInterlockedSub((dest), 1)
-#define IL_HAVE_INTERLOCKED_DECREMENT 1
-#endif
-#if !defined(IL_HAVE_INTERLOCKED_DECREMENT_ACQUIRE) && \
- defined(IL_HAVE_INTERLOCKED_SUB_ACQUIRE)
-#define ILInterlockedDecrement_Acquire(dest) \
- ILInterlockedSub_Acquire((dest), 1)
-#define IL_HAVE_INTERLOCKED_DECREMENT_ACQUIRE 1
-#endif
-#if !defined(IL_HAVE_INTERLOCKED_DECREMENT_RELEASE) && \
- defined(IL_HAVE_INTERLOCKED_SUB_RELEASE)
-#define ILInterlockedDecrement_Release(dest) \
- ILInterlockedSub_Release((dest), 1)
-#define IL_HAVE_INTERLOCKED_DECREMENT_RELEASE 1
-#endif
-#if !defined(IL_HAVE_INTERLOCKED_DECREMENT_FULL) && \
- defined(IL_HAVE_INTERLOCKED_SUB_FULL)
-#define ILInterlockedDecrement_Full(dest) \
- ILInterlockedSub_Full((dest), 1)
-#define IL_HAVE_INTERLOCKED_DECREMENT_FULL 1
-#endif
-#if !defined(IL_HAVE_INTERLOCKED_DECREMENT)
-#define ILInterlockedDecrement(dest) _ILInterlockedDecrement((dest))
-#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENT) */
-#if !defined(IL_HAVE_INTERLOCKED_DECREMENT_ACQUIRE)
-#define ILInterlockedDecrement_Acquire(dest) _ILInterlockedDecrement((dest))
-#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENT_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_DECREMENT_RELEASE)
-#define ILInterlockedDecrement_Release(dest) _ILInterlockedDecrement((dest))
-#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENT_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_DECREMENT_FULL)
-#define ILInterlockedDecrement_Full(dest) _ILInterlockedDecrement((dest))
-#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENT_FULL) */
-
-/*
- * Atomic bitwise AND of unsigned 32 bit values
- */
-static IL_INLINE void _ILInterlockedAnd(volatile ILUInt32 *dest,
-
ILUInt32 value)
-{
- ILThreadAtomicStart();
+#define IL_HAVE_INTERLOCKED_ADDI8_FULL 1
+#endif
- *dest &= value;
+#if !defined(IL_HAVE_INTERLOCKED_SUBI4) && \
+ defined(IL_HAVE_INTERLOCKED_ADDI4)
+#define ILInterlockedSubI4(dest, value) ILInterlockedAddI4((dest),
-(value))
+#define IL_HAVE_INTERLOCKED_SUBI4 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_SUBI4_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_ADDI4_FULL)
+#define ILInterlockedSubI4_Full(dest, value) \
+ ILInterlockedAddI4_Full((dest), -(value))
+#define IL_HAVE_INTERLOCKED_SUBI4_FULL 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_SUBI8) && \
+ defined(IL_HAVE_INTERLOCKED_ADDI8)
+#define ILInterlockedSubI8(dest, value) ILInterlockedAddI8((dest),
-(value))
+#define IL_HAVE_INTERLOCKED_SUBI8 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_SUBI8_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_ADDI8_FULL)
+#define ILInterlockedSubI8_Full(dest, value) \
+ ILInterlockedAddI8_Full((dest), -(value))
+#define IL_HAVE_INTERLOCKED_SUBI8_FULL 1
+#endif
- ILThreadAtomicEnd();
-}
-#if defined(IL_HAVE_INTERLOCKED_AND_FULL)
-#if !defined(IL_HAVE_INTERLOCKED_AND_ACQUIRE)
-#define ILInterlockedAnd_Acquire(dest, value) \
- ILInterlockedAnd_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_AND_ACQUIRE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_AND_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_AND_RELEASE)
-#define ILInterlockedAnd_Release(dest, value) \
- ILInterlockedAnd_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_AND_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_AND_RELEASE) */
-#endif /* defined(IL_HAVE_INTERLOCKED_AND_FULL) */
-#if !defined(IL_HAVE_INTERLOCKED_AND)
-#if defined(IL_HAVE_INTERLOCKED_AND_ACQUIRE)
-#define ILInterlockedAnd(dest, value) \
- ILInterlockedAnd_Acquire((dest), (value))
-#define IL_HAVE_INTERLOCKED_AND 1
-#elif defined(IL_HAVE_INTERLOCKED_AND_RELEASE)
-#define ILInterlockedAnd(dest, value) \
- ILInterlockedAnd_Release((dest), (value))
-#define IL_HAVE_INTERLOCKED_AND 1
-#elif defined(IL_HAVE_INTERLOCKED_AND_FULL)
-#define ILInterlockedAnd(dest, value) \
- ILInterlockedAnd_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_AND 1
-#endif /* defined(IL_HAVE_INTERLOCKED_AND_FULL) */
-#endif /* !defined(IL_HAVE_INTERLOCKED_AND) */
-#if !defined(IL_HAVE_INTERLOCKED_AND) && \
- defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE)
-static IL_INLINE void ILInterlockedAnd(volatile ILInt32 *dest,
-
ILInt32 value)
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI4) && \
+ defined(IL_HAVE_INTERLOCKED_ADDI4)
+#define ILInterlockedIncrementI4(dest) ILInterlockedAddI4((dest), 1)
+#define IL_HAVE_INTERLOCKED_INCREMENTI4 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_ADDI4_FULL)
+#define ILInterlockedIncrementI4_Full(dest) \
+ ILInterlockedAddI4_Full((dest), 1)
+#define IL_HAVE_INTERLOCKED_INCREMENTI4_FULL 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI8) && \
+ defined(IL_HAVE_INTERLOCKED_ADDI8)
+#define ILInterlockedIncrementI8(dest) ILInterlockedAddI8((dest), 1)
+#define IL_HAVE_INTERLOCKED_INCREMENTI8 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_ADDI8_FULL)
+#define ILInterlockedIncrementI8_Full(dest) \
+ ILInterlockedAddI8_Full((dest), 1)
+#define IL_HAVE_INTERLOCKED_INCREMENTI8_FULL 1
+#endif
+
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI4) && \
+ defined(IL_HAVE_INTERLOCKED_SUBI4)
+#define ILInterlockedDecrementI4(dest) ILInterlockedSubI4((dest), 1)
+#define IL_HAVE_INTERLOCKED_DECREMENTI4 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_SUBI4_FULL)
+#define ILInterlockedDecrementI4_Full(dest) \
+ ILInterlockedSubI4_Full((dest), 1)
+#define IL_HAVE_INTERLOCKED_DECREMENTI4_FULL 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI8) && \
+ defined(IL_HAVE_INTERLOCKED_SUBI8)
+#define ILInterlockedDecrementI8(dest) ILInterlockedSubI8((dest), 1)
+#define IL_HAVE_INTERLOCKED_DECREMENTI8 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_SUBI8_FULL)
+#define ILInterlockedDecrementI8_Full(dest) \
+ ILInterlockedSubI8_Full((dest), 1)
+#define IL_HAVE_INTERLOCKED_DECREMENTI8_FULL 1
+#endif
+
+#if !defined(IL_HAVE_INTERLOCKED_ANDUI4) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4)
+static IL_INLINE void ILInterlockedAndU4(volatile ILUInt32 *dest,
+
ILUInt32 value)
{
- ILInt32 oldval;
- ILInt32 retval;
+ ILUInt32 oldval;
+ ILUInt32 retval;
do
{
- oldval = ILInterlockedLoad(dest);
+ oldval = ILInterlockedLoadU4(dest);
retval = oldval & value;
- } while(ILInterlockedCompareAndExchange(dest, retval, oldval) !=
oldVal);
+ } while(ILInterlockedCompareAndExchangeU4(dest, retval, oldval) !=
oldval);
}
-#define IL_HAVE_INTERLOCKED_AND 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_AND) */
-#if !defined(IL_HAVE_INTERLOCKED_AND_ACQUIRE) && \
- defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_ACQUIRE)
-static IL_INLINE void ILInterlockedAnd_Acquire(volatile ILInt32 *dest,
-
ILInt32 value)
+#define IL_HAVE_INTERLOCKED_ANDU4 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_ANDU4_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_FULL)
+static IL_INLINE void ILInterlockedAndU4_Full(volatile ILUInt32 *dest,
+
ILUInt32 value)
{
- ILInt32 oldval;
- ILInt32 retval;
+ ILUInt32 oldval;
+ ILUInt32 retval;
do
{
- oldval = ILInterlockedLoad(dest);
+ oldval = ILInterlockedLoadU4(dest);
retval = oldval & value;
- } while(ILInterlockedCompareAndExchange_Acquire(dest, retval, oldval)
!= oldval);
+ } while(ILInterlockedCompareAndExchangeU4_Full(dest, retval, oldval) !=
oldval);
}
-#define IL_HAVE_INTERLOCKED_AND_ACQUIRE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_AND_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_AND_RELEASE) && \
- defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_RELEASE)
-static IL_INLINE void ILInterlockedAnd_Release(volatile ILInt32 *dest,
-
ILInt32 value)
+#define IL_HAVE_INTERLOCKED_ANDU4_FULL 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_ANDU8) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8)
+static IL_INLINE void ILInterlockedAndU8(volatile ILUInt64 *dest,
+
ILUInt64 value)
{
- ILInt32 oldval;
- ILInt32 retval;
+ ILUInt64 oldval;
+ ILUInt64 retval;
do
{
- oldval = ILInterlockedLoad(dest);
+ oldval = ILInterlockedLoadU8(dest);
retval = oldval & value;
- } while(ILInterlockedCompareAndExchange_Release(dest, retval, oldval)
!= oldval);
+ } while(ILInterlockedCompareAndExchangeU8(dest, retval, oldval) !=
oldval);
}
-#define IL_HAVE_INTERLOCKED_AND_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_AND_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_AND_FULL) && \
- defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_FULL)
-static IL_INLINE void ILInterlockedAnd_Full(volatile ILInt32 *dest,
-
ILInt32 value)
+#define IL_HAVE_INTERLOCKED_ANDU8 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_ANDU8_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_FULL)
+static IL_INLINE void ILInterlockedAndU8_Full(volatile ILUInt64 *dest,
+
ILUInt64 value)
{
- ILInt32 oldval;
- ILInt32 retval;
+ ILUInt64 oldval;
+ ILUInt64 retval;
do
{
- oldval = ILInterlockedLoad(dest);
+ oldval = ILInterlockedLoadU8(dest);
retval = oldval & value;
- } while(ILInterlockedCompareAndExchange_Full(dest, retval, oldval) !=
oldval);
+ } while(ILInterlockedCompareAndExchangeU8_Full(dest, retval, oldval) !=
oldval);
}
-#define IL_HAVE_INTERLOCKED_AND_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_AND_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_AND)
-#define ILInterlockedAnd(dest, value) _ILInterlockedAnd((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_AND) */
-#if !defined(IL_HAVE_INTERLOCKED_AND_ACQUIRE)
-#define ILInterlockedAnd_Acquire(dest, value) _ILInterlockedAnd((dest),
(value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_AND_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_AND_RELEASE)
-#define ILInterlockedAnd_Release(dest, value) _ILInterlockedAnd((dest),
(value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_AND_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_AND_FULL)
-#define ILInterlockedAnd_Full(dest, value) _ILInterlockedAnd((dest),
(value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_AND_FULL) */
+#define IL_HAVE_INTERLOCKED_ANDU8_FULL 1
+#endif
-/*
- * Atomic bitwise OR of unsigned 32 bit values
- */
-static IL_INLINE void _ILInterlockedOr(volatile ILUInt32 *dest,
-
ILUInt32 value)
+#if !defined(IL_HAVE_INTERLOCKED_ORUI4) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4)
+static IL_INLINE void ILInterlockedOrU4(volatile ILUInt32 *dest,
+
ILUInt32 value)
{
- ILThreadAtomicStart();
-
- *dest |= value;
+ ILUInt32 oldval;
+ ILUInt32 retval;
- ILThreadAtomicEnd();
+ do
+ {
+ oldval = ILInterlockedLoadU4(dest);
+ retval = oldval | value;
+ } while(ILInterlockedCompareAndExchangeU4(dest, retval, oldval) !=
oldval);
}
-#if defined(IL_HAVE_INTERLOCKED_OR_FULL)
-#if !defined(IL_HAVE_INTERLOCKED_OR_ACQUIRE)
-#define ILInterlockedOr_Acquire(dest, value) \
- ILInterlockedOr_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_OR_ACQUIRE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_OR_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_OR_RELEASE)
-#define ILInterlockedOr_Release(dest, value) \
- ILInterlockedOr_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_OR_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_OR_RELEASE) */
-#endif /* defined(IL_HAVE_INTERLOCKED_OR_FULL) */
-#if !defined(IL_HAVE_INTERLOCKED_OR)
-#if defined(IL_HAVE_INTERLOCKED_OR_ACQUIRE)
-#define ILInterlockedOr(dest, value) \
- ILInterlockedOr_Acquire((dest), (value))
-#define IL_HAVE_INTERLOCKED_OR 1
-#elif defined(IL_HAVE_INTERLOCKED_OR_RELEASE)
-#define ILInterlockedOr(dest, value) \
- ILInterlockedOr_Release((dest), (value))
-#define IL_HAVE_INTERLOCKED_OR 1
-#elif defined(IL_HAVE_INTERLOCKED_OR_FULL)
-#define ILInterlockedOr(dest, value) \
- ILInterlockedOr_Full((dest), (value))
-#define IL_HAVE_INTERLOCKED_OR 1
-#endif /* defined(IL_HAVE_INTERLOCKED_OR_FULL) */
-#endif /* !defined(IL_HAVE_INTERLOCKED_OR) */
-#if !defined(IL_HAVE_INTERLOCKED_OR) && \
- defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE)
-static IL_INLINE void ILInterlockedOr(volatile ILInt32 *dest,
-
ILInt32 value)
+#define IL_HAVE_INTERLOCKED_ORU4 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_ORU4_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_FULL)
+static IL_INLINE void ILInterlockedOrU4_Full(volatile ILUInt32 *dest,
+
ILUInt32 value)
{
- ILInt32 oldval;
- ILInt32 retval;
+ ILUInt32 oldval;
+ ILUInt32 retval;
do
{
- oldval = ILInterlockedLoad(dest);
+ oldval = ILInterlockedLoadU4(dest);
retval = oldval | value;
- } while(ILInterlockedCompareAndExchange(dest, retval, oldval) !=
oldVal);
+ } while(ILInterlockedCompareAndExchangeU4_Full(dest, retval, oldval) !=
oldval);
}
-#define IL_HAVE_INTERLOCKED_OR 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_OR) */
-#if !defined(IL_HAVE_INTERLOCKED_OR_ACQUIRE) && \
- defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_ACQUIRE)
-static IL_INLINE void ILInterlockedOr_Acquire(volatile ILInt32 *dest,
-
ILInt32 value)
+#define IL_HAVE_INTERLOCKED_ORU4_FULL 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_ORU8) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8)
+static IL_INLINE void ILInterlockedOrU8(volatile ILUInt64 *dest,
+
ILUInt64 value)
{
- ILInt32 oldval;
- ILInt32 retval;
+ ILUInt64 oldval;
+ ILUInt64 retval;
do
{
- oldval = ILInterlockedLoad(dest);
+ oldval = ILInterlockedLoadU8(dest);
retval = oldval | value;
- } while(ILInterlockedCompareAndExchange_Acquire(dest, retval, oldval)
!= oldval);
+ } while(ILInterlockedCompareAndExchangeU8(dest, retval, oldval) !=
oldval);
}
-#define IL_HAVE_INTERLOCKED_OR_ACQUIRE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_OR_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_OR_RELEASE) && \
- defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_RELEASE)
-static IL_INLINE void ILInterlockedOr_Release(volatile ILInt32 *dest,
-
ILInt32 value)
+#define IL_HAVE_INTERLOCKED_ORU8 1
+#endif
+#if !defined(IL_HAVE_INTERLOCKED_ORU8_FULL) && \
+ defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_FULL)
+static IL_INLINE void ILInterlockedOrU8_Full(volatile ILUInt64 *dest,
+
ILUInt64 value)
{
- ILInt32 oldval;
- ILInt32 retval;
+ ILUInt64 oldval;
+ ILUInt64 retval;
do
{
- oldval = ILInterlockedLoad(dest);
+ oldval = ILInterlockedLoadU8(dest);
retval = oldval | value;
- } while(ILInterlockedCompareAndExchange_Release(dest, retval, oldval)
!= oldval);
+ } while(ILInterlockedCompareAndExchangeU8_Full(dest, retval, oldval) !=
oldval);
}
-#define IL_HAVE_INTERLOCKED_OR_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_OR_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_OR_FULL) && \
- defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_FULL)
-static IL_INLINE void ILInterlockedOr_Full(volatile ILInt32 *dest,
-
ILInt32 value)
+#define IL_HAVE_INTERLOCKED_ORU8_FULL 1
+#endif
+
+/*
+ * Compare and exchange two signed 32 bit integers.
+ */
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_ACQUIRE)
+static IL_INLINE ILInt32 ILInterlockedCompareAndExchangeI4_Acquire(volatile
ILInt32 *dest,
+
ILInt32 value,
+
ILInt32 comparand)
{
- ILInt32 oldval;
ILInt32 retval;
- do
+ retval = ILInterlockedCompareAndExchangeI4(dest, value, comparand);
+ ILInterlockedMemoryBarrier();
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_RELEASE)
+static IL_INLINE ILInt32 ILInterlockedCompareAndExchangeI4_Release(volatile
ILInt32 *dest,
+
ILInt32 value,
+
ILInt32 comparand)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedCompareAndExchangeI4(dest, value, comparand);
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL)
+static IL_INLINE ILInt32 ILInterlockedCompareAndExchangeI4_Full(volatile
ILInt32 *dest,
+
ILInt32 value,
+
ILInt32 comparand)
+{
+ ILInt32 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedCompareAndExchangeI4(dest, value, comparand);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4) */
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_ACQUIRE)
+#define ILInterlockedCompareAndExchangeI4_Acquire(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI4_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_RELEASE)
+#define ILInterlockedCompareAndExchangeI4_Release(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI4_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4)
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_ACQUIRE)
+#define ILInterlockedCompareAndExchangeI4(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI4_Acquire((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4 1
+#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_RELEASE)
+#define ILInterlockedCompareAndExchangeI4(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI4_Release((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4 1
+#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL)
+#define ILInterlockedCompareAndExchangeI4(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI4_Full((dest), (value),,
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4) */
+
+/*
+ * Compare and exchange two unsigned 32 bit integers.
+ */
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_ACQUIRE)
+static IL_INLINE ILUInt32 ILInterlockedCompareAndExchangeU4_Acquire(volatile
ILUInt32 *dest,
+
ILUInt32 value,
+
ILUInt32 comparand)
+{
+ ILUInt32 retval;
+
+ retval = ILInterlockedCompareAndExchangeU4(dest, value, comparand);
+ ILInterlockedMemoryBarrier();
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_RELEASE)
+static IL_INLINE ILUInt32 ILInterlockedCompareAndExchangeU4_Release(volatile
ILUInt32 *dest,
+
ILUInt32 value,
+
ILUInt32 comparand)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedCompareAndExchangeU4(dest, value, comparand);
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_FULL)
+static IL_INLINE ILUInt32 ILInterlockedCompareAndExchangeU4_Full(volatile
ILUInt32 *dest,
+
ILUInt32 value,
+
ILUInt32 comparand)
+{
+ ILUInt32 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedCompareAndExchangeU4(dest, value, comparand);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4) */
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_ACQUIRE)
+#define ILInterlockedCompareAndExchangeU4_Acquire(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU4_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_RELEASE)
+#define ILInterlockedCompareAndExchangeU4_Release(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU4_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4)
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_ACQUIRE)
+#define ILInterlockedCompareAndExchangeU4(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU4_Acquire((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4 1
+#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_RELEASE)
+#define ILInterlockedCompareAndExchangeU4(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU4_Release((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4 1
+#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_FULL)
+#define ILInterlockedCompareAndExchangeU4(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU4_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4) */
+
+/*
+ * Compare and exchange two single precision floatingpoint integers.
+ */
+
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_ACQUIRE)
+static IL_INLINE ILFloat ILInterlockedCompareAndExchangeR4_Acquire(volatile
ILFloat *dest,
+
ILFloat value,
+
ILFloat comparand)
+{
+ ILFloat retval;
+
+ retval = ILInterlockedCompareAndExchangeR4(dest, value, comparand);
+ ILInterlockedMemoryBarrier();
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_RELEASE)
+static IL_INLINE ILFloat ILInterlockedCompareAndExchangeR4_Release(volatile
ILFloat *dest,
+
ILFloat value,
+
ILFloat comparand)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedCompareAndExchangeR4(dest, value, comparand);
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_FULL)
+static IL_INLINE ILFloat ILInterlockedCompareAndExchangeR4_Full(volatile
ILFloat *dest,
+
ILFloat value,
+
ILFloat comparand)
+{
+ ILFloat retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedCompareAndExchangeR4(dest, value, comparand);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4) */
+
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_ACQUIRE)
+#define ILInterlockedCompareAndExchangeR4_Acquire(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeR4_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_RELEASE)
+#define ILInterlockedCompareAndExchangeR4_Release(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeR4_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4)
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_ACQUIRE)
+#define ILInterlockedCompareAndExchangeR4(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeR4_Acquire((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4 1
+#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_RELEASE)
+#define ILInterlockedCompareAndExchangeR4(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeR4_Release((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4 1
+#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_FULL)
+#define ILInterlockedCompareAndExchangeR4(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeR4_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4) */
+
+/*
+ * Compare and exchange two signed 64 bit integers.
+ */
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_ACQUIRE)
+static IL_INLINE ILInt64 ILInterlockedCompareAndExchangeI8_Acquire(volatile
ILInt64 *dest,
+
ILInt64 value,
+
ILInt64 comparand)
+{
+ ILInt64 retval;
+
+ retval = ILInterlockedCompareAndExchangeI8(dest, value, comparand);
+ ILInterlockedMemoryBarrier();
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_RELEASE)
+static IL_INLINE ILInt64 ILInterlockedCompareAndExchangeI8_Release(volatile
ILInt64 *dest,
+
ILInt64 value,
+
ILInt64 comparand)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedCompareAndExchangeI8(dest, value, comparand);
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL)
+static IL_INLINE ILInt64 ILInterlockedCompareAndExchangeI8_Full(volatile
ILInt64 *dest,
+
ILInt64 value,
+
ILInt64 comparand)
+{
+ ILInt64 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedCompareAndExchangeI8(dest, value, comparand);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8) */
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_ACQUIRE)
+#define ILInterlockedCompareAndExchangeI8_Acquire(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI8_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_RELEASE)
+#define ILInterlockedCompareAndExchangeI8_Release(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI8_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8)
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_ACQUIRE)
+#define ILInterlockedCompareAndExchangeI8(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI8_Acquire((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8 1
+#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_RELEASE)
+#define ILInterlockedCompareAndExchangeI8(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI8_Release((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8 1
+#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL)
+#define ILInterlockedCompareAndExchangeI8(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeI8_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8) */
+
+/*
+ * Compare and exchange two unsigned 64 bit integers.
+ */
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_ACQUIRE)
+static IL_INLINE ILUInt64 ILInterlockedCompareAndExchangeU8_Acquire(volatile
ILUInt64 *dest,
+
ILUInt64 value,
+
ILUInt64 comparand)
+{
+ ILUInt64 retval;
+
+ retval = ILInterlockedCompareAndExchangeU8(dest, value, comparand);
+ ILInterlockedMemoryBarrier();
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_RELEASE)
+static IL_INLINE ILUInt64 ILInterlockedCompareAndExchangeU8_Release(volatile
ILUInt64 *dest,
+
ILUInt64 value,
+
ILUInt64 comparand)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedCompareAndExchangeU8(dest, value, comparand);
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_FULL)
+static IL_INLINE ILUInt64 ILInterlockedCompareAndExchangeU8_Full(volatile
ILUInt64 *dest,
+
ILUInt64 value,
+
ILUInt64 comparand)
+{
+ ILUInt64 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedCompareAndExchangeU8(dest, value, comparand);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8) */
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_ACQUIRE)
+#define ILInterlockedCompareAndExchangeU8_Acquire(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU8_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_RELEASE)
+#define ILInterlockedCompareAndExchangeU8_Release(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU8_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8)
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_ACQUIRE)
+#define ILInterlockedCompareAndExchangeU8(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU8_Acquire((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8 1
+#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_RELEASE)
+#define ILInterlockedCompareAndExchangeU8(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU8_Release((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8 1
+#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_FULL)
+#define ILInterlockedCompareAndExchangeU8(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeU8_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8) */
+
+/*
+ * Compare and exchange two double precision floatingpoint values.
+ */
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_ACQUIRE)
+static IL_INLINE ILDouble ILInterlockedCompareAndExchangeR8_Acquire(volatile
ILDouble *dest,
+
ILDouble value,
+
ILDouble comparand)
+{
+ ILDouble retval;
+
+ retval = ILInterlockedCompareAndExchangeR8(dest, value, comparand);
+ ILInterlockedMemoryBarrier();
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_RELEASE)
+static IL_INLINE ILDouble ILInterlockedCompareAndExchangeR8_Release(volatile
ILDouble *dest,
+
ILDouble value,
+
ILDouble comparand)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedCompareAndExchangeR8(dest, value, comparand);
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_FULL)
+static IL_INLINE ILDouble ILInterlockedCompareAndExchangeR8_Full(volatile
ILDouble *dest,
+
ILDouble value,
+
ILDouble comparand)
+{
+ ILDouble retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedCompareAndExchangeR8(dest, value, comparand);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8) */
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_ACQUIRE)
+#define ILInterlockedCompareAndExchangeR8_Acquire(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeR8_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_RELEASE)
+#define ILInterlockedCompareAndExchangeR8_Release(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeR8_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8)
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_ACQUIRE)
+#define ILInterlockedCompareAndExchangeR8(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeRU8_Acquire((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8 1
+#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_RELEASE)
+#define ILInterlockedCompareAndExchangeR8(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeR8_Release((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8 1
+#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_FULL)
+#define ILInterlockedCompareAndExchangeR8(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeR8_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8) */
+
+/*
+ * Compare and exchange two pointers.
+ */
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_ACQUIRE)
+static IL_INLINE void *ILInterlockedCompareAndExchangeP_Acquire(void *
volatile *dest,
+
void *value,
+
void *comparand)
+{
+ void *retval;
+
+ retval = ILInterlockedCompareAndExchangeP(dest, value, comparand);
+ ILInterlockedMemoryBarrier();
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_RELEASE)
+static IL_INLINE void *ILInterlockedCompareAndExchangeP_Release(void *
volatile *dest,
+
void *value,
+
void *comparand)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedCompareAndExchangeP(dest, value, comparand);
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL)
+static IL_INLINE void *ILInterlockedCompareAndExchangeP_Full(void * volatile
*dest,
+
void *value,
+
void *comparand)
+{
+ void *retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedCompareAndExchangeP(dest, value, comparand);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP) */
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_ACQUIRE)
+#define ILInterlockedCompareAndExchangeP_Acquire(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeP_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_RELEASE)
+#define ILInterlockedCompareAndExchangeP_Release(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeP_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP)
+#if defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_ACQUIRE)
+#define ILInterlockedCompareAndExchangeP(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeP_Acquire((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP 1
+#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_RELEASE)
+#define ILInterlockedCompareAndExchangeP(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeP_Release((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP 1
+#elif defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL)
+#define ILInterlockedCompareAndExchangeP(dest, value, comparand) \
+ ILInterlockedCompareAndExchangeP_Full((dest), (value),
(comparand))
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP) */
+
+/*
+ * Add the two signed 32bit integers *dest and value and store the result
+ * at *dest.
+ */
+#if defined(IL_HAVE_INTERLOCKED_ADDI4)
+#if !defined(IL_HAVE_INTERLOCKED_ADDI4_ACQUIRE)
+static IL_INLINE ILInt32 ILInterlockedAddI4_Acquire(volatile ILInt32 *dest,
+
ILInt32 value)
+{
+ ILInt32 retval;
+
+ retval = ILInterlockedAddI4(dest, value);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_ADDI4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ADDI4_RELEASE)
+static IL_INLINE ILInt32 ILInterlockedAddI4_Release(volatile ILInt32 *dest,
+
ILInt32 value)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedAddI4(dest, value);
+}
+#define IL_HAVE_INTERLOCKED_ADDI4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_ADDI4_FULL)
+static IL_INLINE ILInt32 ILInterlockedAddI4_Full(volatile ILInt32 *dest,
+
ILInt32 value)
+{
+ ILInt32 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedAddI4(dest, value);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_ADDI4_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI4_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_ADDI4) */
+#if defined(IL_HAVE_INTERLOCKED_ADDI4_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_ADDI4_ACQUIRE)
+#define ILInterlockedAddI4_Acquire(dest, value) \
+ ILInterlockedAddI4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ADDI4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ADDI4_RELEASE)
+#define ILInterlockedAddI4_Release(dest, value) \
+ ILInterlockedAddI4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ADDI4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI4_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_ADDI4_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_ADDI4)
+#if defined(IL_HAVE_INTERLOCKED_ADDI4_ACQUIRE)
+#define ILInterlockedAddI4(dest, value) \
+ ILInterlockedAddI4_Acquire((dest), (value))
+#define IL_HAVE_INTERLOCKED_ADDI4 1
+#elif defined(IL_HAVE_INTERLOCKED_ADDI4_RELEASE)
+#define ILInterlockedAddI4(dest, value) \
+ ILInterlockedAddI4_Release((dest), (value))
+#define IL_HAVE_INTERLOCKED_ADDI4 1
+#elif defined(IL_HAVE_INTERLOCKED_ADDI4_FULL)
+#define ILInterlockedAddI4(dest, value) \
+ ILInterlockedAddI4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ADDI4 1
+#endif /* defined(IL_HAVE_INTERLOCKED_ADDI4_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI4) */
+
+/*
+ * Add the two signed 64bit integers *dest and value and store the result
+ * at *dest.
+ */
+#if defined(IL_HAVE_INTERLOCKED_ADDI8)
+#if !defined(IL_HAVE_INTERLOCKED_ADDI8_ACQUIRE)
+static IL_INLINE ILInt64 ILInterlockedAddI8_Acquire(volatile ILInt64 *dest,
+
ILInt64 value)
+{
+ ILInt64 retval;
+
+ retval = ILInterlockedAddI8(dest, value);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_ADDI8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ADDI8_RELEASE)
+static IL_INLINE ILInt64 ILInterlockedAddI8_Release(volatile ILInt64 *dest,
+
ILInt64 value)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedAddI8(dest, value);
+}
+#define IL_HAVE_INTERLOCKED_ADDI8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_ADDI8_FULL)
+static IL_INLINE ILInt64 ILInterlockedAddI8_Full(volatile ILInt64 *dest,
+
ILInt64 value)
+{
+ ILInt64 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedAddI8(dest, value);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_ADDI8_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI8_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_ADDI8) */
+#if defined(IL_HAVE_INTERLOCKED_ADDI8_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_ADDI8_ACQUIRE)
+#define ILInterlockedAddI8_Acquire(dest, value) \
+ ILInterlockedAddI8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ADDI8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ADDI8_RELEASE)
+#define ILInterlockedAddI8_Release(dest, value) \
+ ILInterlockedAddI8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ADDI8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI8_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_ADDI8_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_ADDI8)
+#if defined(IL_HAVE_INTERLOCKED_ADDI8_ACQUIRE)
+#define ILInterlockedAddI8(dest, value) \
+ ILInterlockedAddI8_Acquire((dest), (value))
+#define IL_HAVE_INTERLOCKED_ADDI8 1
+#elif defined(IL_HAVE_INTERLOCKED_ADDI8_RELEASE)
+#define ILInterlockedAddI8(dest, value) \
+ ILInterlockedAddI8_Release((dest), (value))
+#define IL_HAVE_INTERLOCKED_ADDI8 1
+#elif defined(IL_HAVE_INTERLOCKED_ADDI8_FULL)
+#define ILInterlockedAddI8(dest, value) \
+ ILInterlockedAddI8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ADDI8 1
+#endif /* defined(IL_HAVE_INTERLOCKED_ADDI8_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI8) */
+
+/*
+ * Subtract the two signed 32bit integers *dest and value and store the
+ * result at *dest.
+ */
+#if defined(IL_HAVE_INTERLOCKED_SUBI4)
+#if !defined(IL_HAVE_INTERLOCKED_SUBI4_ACQUIRE)
+static IL_INLINE ILInt32 ILInterlockedSubI4_Acquire(volatile ILInt32 *dest,
+
ILInt32 value)
+{
+ ILInt32 retval;
+
+ retval = ILInterlockedSubI4(dest, value);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_SUBI4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_SUBI4_RELEASE)
+static IL_INLINE ILInt32 ILInterlockedSubI4_Release(volatile ILInt32 *dest,
+
ILInt32 value)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedSubI4(dest, value);
+}
+#define IL_HAVE_INTERLOCKED_SUBI4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_SUBI4_FULL)
+static IL_INLINE ILInt32 ILInterlockedSubI4_Full(volatile ILInt32 *dest,
+
ILInt32 value)
+{
+ ILInt32 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedSubI4(dest, value);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_SUBI4_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI4_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_SUBI4) */
+#if defined(IL_HAVE_INTERLOCKED_SUBI4_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_SUBI4_ACQUIRE)
+#define ILInterlockedSubI4_Acquire(dest, value) \
+ ILInterlockedSubI4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_SUBI4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_SUBI4_RELEASE)
+#define ILInterlockedSubI4_Release(dest, value) \
+ ILInterlockedSubI4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_SUBI4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI4_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_SUBI4_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_SUBI4)
+#if defined(IL_HAVE_INTERLOCKED_SUBI4_ACQUIRE)
+#define ILInterlockedSubI4(dest, value) \
+ ILInterlockedSubI4_Acquire((dest), (value))
+#define IL_HAVE_INTERLOCKED_SUBI4 1
+#elif defined(IL_HAVE_INTERLOCKED_SUBI4_RELEASE)
+#define ILInterlockedSubI4(dest, value) \
+ ILInterlockedSubI4_Release((dest), (value))
+#define IL_HAVE_INTERLOCKED_SUBI4 1
+#elif defined(IL_HAVE_INTERLOCKED_SUBI4_FULL)
+#define ILInterlockedSubI4(dest, value) \
+ ILInterlockedSubI4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_SUBI4 1
+#endif /* defined(IL_HAVE_INTERLOCKED_SUBI4_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI4) */
+
+/*
+ * Subtract the two signed 64bit integers *dest and value and store the
+ * result at *dest.
+ */
+#if defined(IL_HAVE_INTERLOCKED_SUBI8)
+#if !defined(IL_HAVE_INTERLOCKED_SUBI8_ACQUIRE)
+static IL_INLINE ILInt64 ILInterlockedSubI8_Acquire(volatile ILInt64 *dest,
+
ILInt64 value)
+{
+ ILInt64 retval;
+
+ retval = ILInterlockedSubI8(dest, value);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_SUBI8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_SUBI8_RELEASE)
+static IL_INLINE ILInt64 ILInterlockedSubI8_Release(volatile ILInt64 *dest,
+
ILInt64 value)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedSubI8(dest, value);
+}
+#define IL_HAVE_INTERLOCKED_SUBI8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_SUBI8_FULL)
+static IL_INLINE ILInt64 ILInterlockedSubI8_Full(volatile ILInt64 *dest,
+
ILInt64 value)
+{
+ ILInt64 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedSubI8(dest, value);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_SUBI8_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI8_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_SUBI8) */
+#if defined(IL_HAVE_INTERLOCKED_SUBI8_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_SUBI8_ACQUIRE)
+#define ILInterlockedSubI8_Acquire(dest, value) \
+ ILInterlockedSubI8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_SUBI8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_SUBI8_RELEASE)
+#define ILInterlockedSubI8_Release(dest, value) \
+ ILInterlockedSubI8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_SUBI8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI8_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_SUBI8_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_SUBI8)
+#if defined(IL_HAVE_INTERLOCKED_SUBI8_ACQUIRE)
+#define ILInterlockedSubI8(dest, value) \
+ ILInterlockedSubI8_Acquire((dest), (value))
+#define IL_HAVE_INTERLOCKED_SUBI8 1
+#elif defined(IL_HAVE_INTERLOCKED_SUBI8_RELEASE)
+#define ILInterlockedSubI8(dest, value) \
+ ILInterlockedSubI8_Release((dest), (value))
+#define IL_HAVE_INTERLOCKED_SUBI8 1
+#elif defined(IL_HAVE_INTERLOCKED_SUBI8_FULL)
+#define ILInterlockedSubI8(dest, value) \
+ ILInterlockedSubI8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_SUBI8 1
+#endif /* defined(IL_HAVE_INTERLOCKED_SUBI8_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI8) */
+
+/*
+ * Increment the signed 32bit integer at *dest.
+ */
+#if defined(IL_HAVE_INTERLOCKED_INCREMENTI4)
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_ACQUIRE)
+static IL_INLINE ILInt32 ILInterlockedIncrementI4_Acquire(volatile ILInt32
*dest)
+{
+ ILInt32 retval;
+
+ retval = ILInterlockedIncrementI4(dest);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_INCREMENTI4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_RELEASE)
+static IL_INLINE ILInt32 ILInterlockedIncrementI4_Release(volatile ILInt32
*dest)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedIncrementI4(dest);
+}
+#define IL_HAVE_INTERLOCKED_INCREMENTI4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_FULL)
+static IL_INLINE ILInt32 ILInterlockedIncrementI4_Full(volatile ILInt32 *dest)
+{
+ ILInt32 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedIncrementI4(dest);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_INCREMENTI4_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_INCREMENTI4) */
+#if defined(IL_HAVE_INTERLOCKED_INCREMENTI4_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_ACQUIRE)
+#define ILInterlockedIncrementI4_Acquire(dest) \
+ ILInterlockedIncrementI4_Full((dest))
+#define IL_HAVE_INTERLOCKED_INCREMENTI4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_RELEASE)
+#define ILInterlockedIncrementI4_Release(dest) \
+ ILInterlockedIncrementI4_Full((dest))
+#define IL_HAVE_INTERLOCKED_INCREMENTI4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_INCREMENTI4_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI4)
+#if defined(IL_HAVE_INTERLOCKED_INCREMENTI4_ACQUIRE)
+#define ILInterlockedIncrementI4(dest) \
+ ILInterlockedIncrementI4_Acquire((dest))
+#define IL_HAVE_INTERLOCKED_INCREMENTI4 1
+#elif defined(IL_HAVE_INTERLOCKED_INCREMENTI4_RELEASE)
+#define ILInterlockedIncrementI4(dest) \
+ ILInterlockedIncrementI4_Release((dest))
+#define IL_HAVE_INTERLOCKED_INCREMENTI4 1
+#elif defined(IL_HAVE_INTERLOCKED_INCREMENTI4_FULL)
+#define ILInterlockedIncrementI4(dest) \
+ ILInterlockedIncrementI4_Full((dest))
+#define IL_HAVE_INTERLOCKED_INCREMENTI4 1
+#endif /* defined(IL_HAVE_INTERLOCKED_INCREMENTI4_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI4) */
+
+/*
+ * Increment the signed 64bit integer at *dest.
+ */
+#if defined(IL_HAVE_INTERLOCKED_INCREMENTI8)
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_ACQUIRE)
+static IL_INLINE ILInt64 ILInterlockedIncrementI8_Acquire(volatile ILInt64
*dest)
+{
+ ILInt64 retval;
+
+ retval = ILInterlockedIncrementI8(dest);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_INCREMENTI8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_RELEASE)
+static IL_INLINE ILInt64 ILInterlockedIncrementI8_Release(volatile ILInt64
*dest)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedIncrementI8(dest);
+}
+#define IL_HAVE_INTERLOCKED_INCREMENTI8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_FULL)
+static IL_INLINE ILInt64 ILInterlockedIncrementI8_Full(volatile ILInt64 *dest)
+{
+ ILInt64 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedIncrementI8(dest);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_INCREMENTI8_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_INCREMENTI8) */
+#if defined(IL_HAVE_INTERLOCKED_INCREMENTI8_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_ACQUIRE)
+#define ILInterlockedIncrementI8_Acquire(dest) \
+ ILInterlockedIncrementI8_Full((dest))
+#define IL_HAVE_INTERLOCKED_INCREMENTI8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_RELEASE)
+#define ILInterlockedIncrementI8_Release(dest) \
+ ILInterlockedIncrementI8_Full((dest))
+#define IL_HAVE_INTERLOCKED_INCREMENTI8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_INCREMENTI8_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI8)
+#if defined(IL_HAVE_INTERLOCKED_INCREMENTI8_ACQUIRE)
+#define ILInterlockedIncrementI8(dest) \
+ ILInterlockedIncrementI8_Acquire((dest))
+#define IL_HAVE_INTERLOCKED_INCREMENTI8 1
+#elif defined(IL_HAVE_INTERLOCKED_INCREMENTI8_RELEASE)
+#define ILInterlockedIncrementI8(dest) \
+ ILInterlockedIncrementI8_Release((dest))
+#define IL_HAVE_INTERLOCKED_INCREMENTI8 1
+#elif defined(IL_HAVE_INTERLOCKED_INCREMENTI8_FULL)
+#define ILInterlockedIncrementI8(dest) \
+ ILInterlockedIncrementI8_Full((dest))
+#define IL_HAVE_INTERLOCKED_INCREMENTI8 1
+#endif /* defined(IL_HAVE_INTERLOCKED_INCREMENTI8_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI8) */
+
+/*
+ * Decrement the signed 32bit integer at *dest.
+ */
+#if defined(IL_HAVE_INTERLOCKED_DECREMENTI4)
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_ACQUIRE)
+static IL_INLINE ILInt32 ILInterlockedDecrementI4_Acquire(volatile ILInt32
*dest)
+{
+ ILInt32 retval;
+
+ retval = ILInterlockedDecrementI4(dest);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_DECREMENTI4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_RELEASE)
+static IL_INLINE ILInt32 ILInterlockedDecrementI4_Release(volatile ILInt32
*dest)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedDecrementI4(dest);
+}
+#define IL_HAVE_INTERLOCKED_DECREMENTI4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_FULL)
+static IL_INLINE ILInt32 ILInterlockedDecrementI4_Full(volatile ILInt32 *dest)
+{
+ ILInt32 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedDecrementI4(dest);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_DECREMENTI4_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_DECREMENTI4) */
+#if defined(IL_HAVE_INTERLOCKED_DECREMENTI4_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_ACQUIRE)
+#define ILInterlockedDecrementI4_Acquire(dest) \
+ ILInterlockedDecrementI4_Full((dest))
+#define IL_HAVE_INTERLOCKED_DECREMENTI4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_RELEASE)
+#define ILInterlockedDecrementI4_Release(dest) \
+ ILInterlockedDecrementI4_Full((dest))
+#define IL_HAVE_INTERLOCKED_DECREMENTI4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_DECREMENTI4_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI4)
+#if defined(IL_HAVE_INTERLOCKED_DECREMENTI4_ACQUIRE)
+#define ILInterlockedDecrementI4(dest) \
+ ILInterlockedDecrementI4_Acquire((dest))
+#define IL_HAVE_INTERLOCKED_DECREMENTI4 1
+#elif defined(IL_HAVE_INTERLOCKED_DECREMENTI4_RELEASE)
+#define ILInterlockedDecrementI4(dest) \
+ ILInterlockedDecrementI4_Release((dest))
+#define IL_HAVE_INTERLOCKED_DECREMENTI4 1
+#elif defined(IL_HAVE_INTERLOCKED_DECREMENTI4_FULL)
+#define ILInterlockedDecrementI4(dest) \
+ ILInterlockedDecrementI4_Full((dest))
+#define IL_HAVE_INTERLOCKED_DECREMENTI4 1
+#endif /* defined(IL_HAVE_INTERLOCKED_DECREMENTI4_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI4) */
+
+/*
+ * Decrement the signed 64bit integer at *dest.
+ */
+#if defined(IL_HAVE_INTERLOCKED_DECREMENTI8)
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_ACQUIRE)
+static IL_INLINE ILInt64 ILInterlockedDecrementI8_Acquire(volatile ILInt64
*dest)
+{
+ ILInt64 retval;
+
+ retval = ILInterlockedDecrementI8(dest);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_DECREMENTI8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_RELEASE)
+static IL_INLINE ILInt64 ILInterlockedDecrementI8_Release(volatile ILInt64
*dest)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedDecrementI8(dest);
+}
+#define IL_HAVE_INTERLOCKED_DECREMENTI8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_FULL)
+static IL_INLINE ILInt64 ILInterlockedDecrementI8_Full(volatile ILInt64 *dest)
+{
+ ILInt64 retval;
+
+ ILInterlockedMemoryBarrier();
+ retval = ILInterlockedDecrementI8(dest);
+ ILInterlockedMemoryBarrier();
+
+ return retval;
+}
+#define IL_HAVE_INTERLOCKED_DECREMENTI8_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_DECREMENTI8) */
+#if defined(IL_HAVE_INTERLOCKED_DECREMENTI8_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_ACQUIRE)
+#define ILInterlockedDecrementI8_Acquire(dest) \
+ ILInterlockedDecrementI8_Full((dest))
+#define IL_HAVE_INTERLOCKED_DECREMENTI8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_RELEASE)
+#define ILInterlockedDecrementI8_Release(dest) \
+ ILInterlockedDecrementI8_Full((dest))
+#define IL_HAVE_INTERLOCKED_DECREMENTI8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_DECREMENTI8_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI8)
+#if defined(IL_HAVE_INTERLOCKED_DECREMENTI8_ACQUIRE)
+#define ILInterlockedDecrementI8(dest) \
+ ILInterlockedDecrementI8_Acquire((dest))
+#define IL_HAVE_INTERLOCKED_DECREMENTI8 1
+#elif defined(IL_HAVE_INTERLOCKED_DECREMENTI8_RELEASE)
+#define ILInterlockedDecrementI8(dest) \
+ ILInterlockedDecrementI8_Release((dest))
+#define IL_HAVE_INTERLOCKED_DECREMENTI8 1
+#elif defined(IL_HAVE_INTERLOCKED_DECREMENTI8_FULL)
+#define ILInterlockedDecrementI8(dest) \
+ ILInterlockedDecrementI8_Full((dest))
+#define IL_HAVE_INTERLOCKED_DECREMENTI8 1
+#endif /* defined(IL_HAVE_INTERLOCKED_DECREMENTI8_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI8) */
+
+/*
+ * Bitwise and of the two unsigned 32bit integers *dest and value and store
+ * the result at *dest.
+ */
+#if defined(IL_HAVE_INTERLOCKED_ANDU4)
+#if !defined(IL_HAVE_INTERLOCKED_ANDU4_ACQUIRE)
+static IL_INLINE void ILInterlockedAndU4_Acquire(volatile ILUInt32 *dest,
+
ILUInt32 value)
+{
+ ILInterlockedAndU4(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#define IL_HAVE_INTERLOCKED_ANDU4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ANDU4_RELEASE)
+static IL_INLINE void ILInterlockedAndU4_Release(volatile ILUInt32 *dest,
+
ILUInt32 value)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedAndU4(dest, value);
+}
+#define IL_HAVE_INTERLOCKED_ANDU4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_ANDU4_FULL)
+static IL_INLINE void ILInterlockedAndU4_Full(volatile ILUInt32 *dest,
+
ILUInt32 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedAndU4(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#define IL_HAVE_INTERLOCKED_ANDU4_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU4_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_ANDU4) */
+#if defined(IL_HAVE_INTERLOCKED_ANDU4_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_ANDU4_ACQUIRE)
+#define ILInterlockedAndU4_Acquire(dest, value) \
+ ILInterlockedAndU4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ANDU4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ANDU4_RELEASE)
+#define ILInterlockedAndU4_Release(dest, value) \
+ ILInterlockedAndU4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ANDU4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU4_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_ANDU4_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_ANDU4)
+#if defined(IL_HAVE_INTERLOCKED_ANDU4_ACQUIRE)
+#define ILInterlockedAndU4(dest, value) \
+ ILInterlockedAndU4_Acquire((dest), (value))
+#define IL_HAVE_INTERLOCKED_ANDU4 1
+#elif defined(IL_HAVE_INTERLOCKED_ANDU4_RELEASE)
+#define ILInterlockedAndU4(dest, value) \
+ ILInterlockedAndU4_Release((dest), (value))
+#define IL_HAVE_INTERLOCKED_ANDU4 1
+#elif defined(IL_HAVE_INTERLOCKED_ANDU4_FULL)
+#define ILInterlockedAndU4(dest, value) \
+ ILInterlockedAndU4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ANDU4 1
+#endif /* defined(IL_HAVE_INTERLOCKED_ANDU4_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU4) */
+
+/*
+ * Bitwise and of the two unsigned 64bit integers *dest and value and store
+ * the result at *dest.
+ */
+#if defined(IL_HAVE_INTERLOCKED_ANDU8)
+#if !defined(IL_HAVE_INTERLOCKED_ANDU8_ACQUIRE)
+static IL_INLINE void ILInterlockedAndU8_Acquire(volatile ILUInt64 *dest,
+
ILUInt64 value)
+{
+ ILInterlockedAndU8(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#define IL_HAVE_INTERLOCKED_ANDU8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ANDU8_RELEASE)
+static IL_INLINE void ILInterlockedAndU8_Release(volatile ILUInt64 *dest,
+
ILUInt64 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedAndU8(dest, value);
+}
+#define IL_HAVE_INTERLOCKED_ANDU8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_ANDU8_FULL)
+static IL_INLINE void ILInterlockedAndU8_Full(volatile ILUInt64 *dest,
+
ILUInt64 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedAndU8(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#define IL_HAVE_INTERLOCKED_ANDU8_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU8_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_ANDU8) */
+#if defined(IL_HAVE_INTERLOCKED_ANDU8_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_ANDU8_ACQUIRE)
+#define ILInterlockedAndU8_Acquire(dest, value) \
+ ILInterlockedAndU8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ANDU8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ANDU8_RELEASE)
+#define ILInterlockedAndU8_Release(dest, value) \
+ ILInterlockedAndU8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ANDU8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU8_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_ANDU8_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_ANDU8)
+#if defined(IL_HAVE_INTERLOCKED_ANDU8_ACQUIRE)
+#define ILInterlockedAndU8(dest, value) \
+ ILInterlockedAndU8_Acquire((dest), (value))
+#define IL_HAVE_INTERLOCKED_ANDU8 1
+#elif defined(IL_HAVE_INTERLOCKED_ANDU8_RELEASE)
+#define ILInterlockedAndU8(dest, value) \
+ ILInterlockedAndU8_Release((dest), (value))
+#define IL_HAVE_INTERLOCKED_ANDU8 1
+#elif defined(IL_HAVE_INTERLOCKED_ANDU8_FULL)
+#define ILInterlockedAndU8(dest, value) \
+ ILInterlockedAndU8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ANDU8 1
+#endif /* defined(IL_HAVE_INTERLOCKED_ANDU8_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU8) */
+
+/*
+ * Bitwise or of the two unsigned 32bit integers *dest and value and store
+ * the result at *dest.
+ */
+#if defined(IL_HAVE_INTERLOCKED_ORU4)
+#if !defined(IL_HAVE_INTERLOCKED_ORU4_ACQUIRE)
+static IL_INLINE void ILInterlockedOrU4_Acquire(volatile ILUInt32 *dest,
+
ILUInt32 value)
+{
+ ILInterlockedOrU4(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#define IL_HAVE_INTERLOCKED_ORU4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ORU4_RELEASE)
+static IL_INLINE void ILInterlockedOrU4_Release(volatile ILUInt32 *dest,
+
ILUInt32 value)
+{
+ ILInterlockedMemoryBarrier();
+ return ILInterlockedOrU4(dest, value);
+}
+#define IL_HAVE_INTERLOCKED_ORU4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_ORU4_FULL)
+static IL_INLINE void ILInterlockedOrU4_Full(volatile ILUInt32 *dest,
+
ILUInt32 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedOrU4(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#define IL_HAVE_INTERLOCKED_ORU4_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU4_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_ORU4) */
+#if defined(IL_HAVE_INTERLOCKED_ORU4_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_ORU4_ACQUIRE)
+#define ILInterlockedOrU4_Acquire(dest, value) \
+ ILInterlockedOrU4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ORU4_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ORU4_RELEASE)
+#define ILInterlockedOrU4_Release(dest, value) \
+ ILInterlockedOrU4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ORU4_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU4_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_ORU4_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_ORU4)
+#if defined(IL_HAVE_INTERLOCKED_ORU4_ACQUIRE)
+#define ILInterlockedOrU4(dest, value) \
+ ILInterlockedOrU4_Acquire((dest), (value))
+#define IL_HAVE_INTERLOCKED_ORU4 1
+#elif defined(IL_HAVE_INTERLOCKED_ORU4_RELEASE)
+#define ILInterlockedOrU4(dest, value) \
+ ILInterlockedOrU4_Release((dest), (value))
+#define IL_HAVE_INTERLOCKED_ORU4 1
+#elif defined(IL_HAVE_INTERLOCKED_ORU4_FULL)
+#define ILInterlockedOrU4(dest, value) \
+ ILInterlockedOrU4_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ORU4 1
+#endif /* defined(IL_HAVE_INTERLOCKED_ORU4_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU4) */
+
+/*
+ * Bitwise and of the two unsigned 64bit integers *dest and value and store
+ * the result at *dest.
+ */
+#if defined(IL_HAVE_INTERLOCKED_ORU8)
+#if !defined(IL_HAVE_INTERLOCKED_ORU8_ACQUIRE)
+static IL_INLINE void ILInterlockedOrU8_Acquire(volatile ILUInt64 *dest,
+
ILUInt64 value)
+{
+ ILInterlockedOrU8(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#define IL_HAVE_INTERLOCKED_ORU8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ORU8_RELEASE)
+static IL_INLINE void ILInterlockedOrU8_Release(volatile ILUInt64 *dest,
+
ILUInt64 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedOrU8(dest, value);
+}
+#define IL_HAVE_INTERLOCKED_ORU8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_ORU8_FULL)
+static IL_INLINE void ILInterlockedOrU8_Full(volatile ILUInt64 *dest,
+
ILUInt64 value)
+{
+ ILInterlockedMemoryBarrier();
+ ILInterlockedOrU8(dest, value);
+ ILInterlockedMemoryBarrier();
+}
+#define IL_HAVE_INTERLOCKED_ORU8_FULL 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU8_FULL) */
+#endif /* defined(IL_HAVE_INTERLOCKED_ORU8) */
+#if defined(IL_HAVE_INTERLOCKED_ORU8_FULL)
+#if !defined(IL_HAVE_INTERLOCKED_ORU8_ACQUIRE)
+#define ILInterlockedOrU8_Acquire(dest, value) \
+ ILInterlockedOrU8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ORU8_ACQUIRE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ORU8_RELEASE)
+#define ILInterlockedOrU8_Release(dest, value) \
+ ILInterlockedOrU8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ORU8_RELEASE 1
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU8_RELEASE) */
+#endif /* defined(IL_HAVE_INTERLOCKED_ORU8_FULL) */
+#if !defined(IL_HAVE_INTERLOCKED_ORU8)
+#if defined(IL_HAVE_INTERLOCKED_ORU8_ACQUIRE)
+#define ILInterlockedOrU8(dest, value) \
+ ILInterlockedOrU8_Acquire((dest), (value))
+#define IL_HAVE_INTERLOCKED_ORU8 1
+#elif defined(IL_HAVE_INTERLOCKED_ORU8_RELEASE)
+#define ILInterlockedOrU8(dest, value) \
+ ILInterlockedOrU8_Release((dest), (value))
+#define IL_HAVE_INTERLOCKED_ORU8 1
+#elif defined(IL_HAVE_INTERLOCKED_ORU8_FULL)
+#define ILInterlockedOrU8(dest, value) \
+ ILInterlockedOrU8_Full((dest), (value))
+#define IL_HAVE_INTERLOCKED_ORU8 1
+#endif /* defined(IL_HAVE_INTERLOCKED_ORU8_FULL) */
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU8) */
+
+/*
+ * Backup declarations if no native implementation is available
+ */
+static IL_INLINE ILInt32 _ILInterlockedExchangeI4_Full(volatile ILInt32 *dest,
+
ILInt32 value)
+{
+ ILInt32 retval;
+
+ ILThreadAtomicStart();
+
+ retval = *dest;
+ *dest = value;
+
+ ILThreadAtomicEnd();
+
+ return retval;
+}
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4)
+#define ILInterlockedExchangeI4(dest, value) \
+ _ILInterlockedExchangeI4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_ACQUIRE)
+#define ILInterlockedExchangeI4_Acquire(dest, value) \
+ _ILInterlockedExchangeI4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_RELEASE)
+#define ILInterlockedExchangeI4_Release(dest, value) \
+ _ILInterlockedExchangeI4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL)
+#define ILInterlockedExchangeI4_Full(dest, value) \
+ _ILInterlockedExchangeI4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL) */
+
+static IL_INLINE ILUInt32 _ILInterlockedExchangeU4_Full(volatile ILUInt32
*dest,
+
ILUInt32 value)
+{
+ ILUInt32 retval;
+
+ ILThreadAtomicStart();
+
+ retval = *dest;
+ *dest = value;
+
+ ILThreadAtomicEnd();
+
+ return retval;
+}
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4)
+#define ILInterlockedExchangeU4(dest, value) \
+ _ILInterlockedExchangeU4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_ACQUIRE)
+#define ILInterlockedExchangeU4_Acquire(dest, value) \
+ _ILInterlockedExchangeU4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_RELEASE)
+#define ILInterlockedExchangeU4_Release(dest, value) \
+ _ILInterlockedExchangeU4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_FULL)
+#define ILInterlockedExchangeU4_Full(dest, value) \
+ _ILInterlockedExchangeU4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU4_FULL) */
+
+static IL_INLINE ILFloat _ILInterlockedExchangeR4_Full(volatile ILFloat *dest,
+
ILFloat value)
+{
+ ILFloat retval;
+
+ ILThreadAtomicStart();
+
+ retval = *dest;
+ *dest = value;
+
+ ILThreadAtomicEnd();
+
+ return retval;
+}
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER4)
+#define ILInterlockedExchangeR4(dest, value) \
+ _ILInterlockedExchangeR4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER4) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_ACQUIRE)
+#define ILInterlockedExchangeR4_Acquire(dest, value) \
+ _ILInterlockedExchangeR4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_RELEASE)
+#define ILInterlockedExchangeR4_Release(dest, value) \
+ _ILInterlockedExchangeR4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_FULL)
+#define ILInterlockedExchangeR4_Full(dest, value) \
+ _ILInterlockedExchangeR4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER4_FULL) */
+
+static IL_INLINE ILInt64 _ILInterlockedExchangeI8_Full(volatile ILInt64 *dest,
+
ILInt64 value)
+{
+ ILInt64 retval;
+
+ ILThreadAtomicStart();
+
+ retval = *dest;
+ *dest = value;
+
+ ILThreadAtomicEnd();
+
+ return retval;
+}
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8)
+#define ILInterlockedExchangeI8(dest, value) \
+ _ILInterlockedExchangeI8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_ACQUIRE)
+#define ILInterlockedExchangeI8_Acquire(dest, value) \
+ _ILInterlockedExchangeI8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_RELEASE)
+#define ILInterlockedExchangeI8_Release(dest, value) \
+ _ILInterlockedExchangeI8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_FULL)
+#define ILInterlockedExchangeI8_Full(dest, value) \
+ _ILInterlockedExchangeI8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEI8_FULL) */
+
+static IL_INLINE ILUInt64 _ILInterlockedExchangeU8_Full(volatile ILUInt64
*dest,
+
ILUInt64 value)
+{
+ ILUInt64 retval;
+
+ ILThreadAtomicStart();
+
+ retval = *dest;
+ *dest = value;
+
+ ILThreadAtomicEnd();
+
+ return retval;
+}
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8)
+#define ILInterlockedExchangeU8(dest, value) \
+ _ILInterlockedExchangeU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_ACQUIRE)
+#define ILInterlockedExchangeU8_Acquire(dest, value) \
+ _ILInterlockedExchangeU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_RELEASE)
+#define ILInterlockedExchangeU8_Release(dest, value) \
+ _ILInterlockedExchangeU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_FULL)
+#define ILInterlockedExchangeU8_Full(dest, value) \
+ _ILInterlockedExchangeU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGEU8_FULL) */
+
+static IL_INLINE ILDouble _ILInterlockedExchangeR8_Full(volatile ILDouble
*dest,
+
ILDouble value)
+{
+ ILDouble retval;
+
+ ILThreadAtomicStart();
+
+ retval = *dest;
+ *dest = value;
+
+ ILThreadAtomicEnd();
+
+ return retval;
+}
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER8)
+#define ILInterlockedExchangeR8(dest, value) \
+ _ILInterlockedExchangeR8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER8) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_ACQUIRE)
+#define ILInterlockedExchangeR8_Acquire(dest, value) \
+ _ILInterlockedExchangeR8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_RELEASE)
+#define ILInterlockedExchangeR8_Release(dest, value) \
+ _ILInterlockedExchangeR8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_FULL)
+#define ILInterlockedExchangeR8_Full(dest, value) \
+ _ILInterlockedExchangeR8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_EXCHANGER8_FULL) */
+
+static IL_INLINE ILInt32 _ILInterlockedCompareAndExchangeI4_Full(volatile
ILInt32 *dest,
+
ILInt32 value,
+
ILInt32 comparand)
+{
+ ILInt32 retval;
+
+ ILThreadAtomicStart();
+
+ retval = *dest;
+
+ if (retval == comparand)
{
- oldval = ILInterlockedLoad(dest);
- retval = oldval | value;
- } while(ILInterlockedCompareAndExchange_Full(dest, retval, oldval) !=
oldval);
-}
-#define IL_HAVE_INTERLOCKED_OR_RELEASE 1
-#endif /* !defined(IL_HAVE_INTERLOCKED_OR_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_OR)
-#define ILInterlockedOr(dest, value) _ILInterlockedOr((dest), (value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_OR) */
-#if !defined(IL_HAVE_INTERLOCKED_OR_ACQUIRE)
-#define ILInterlockedOr_Acquire(dest, value) _ILInterlockedOr((dest),
(value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_OR_ACQUIRE) */
-#if !defined(IL_HAVE_INTERLOCKED_OR_RELEASE)
-#define ILInterlockedOr_Release(dest, value) _ILInterlockedOr((dest),
(value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_OR_RELEASE) */
-#if !defined(IL_HAVE_INTERLOCKED_OR_FULL)
-#define ILInterlockedOr_Full(dest, value) _ILInterlockedOr((dest),
(value))
-#endif /* !defined(IL_HAVE_INTERLOCKED_OR_FULL) */
+ *dest = value;
+ }
+
+ ILThreadAtomicEnd();
+
+ return retval;
+}
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4)
+#define ILInterlockedCompareAndExchangeI4(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeI4_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_ACQUIRE)
+#define ILInterlockedCompareAndExchangeI4_Acquire(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeI4_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_RELEASE)
+#define ILInterlockedCompareAndExchangeI4_Release(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeI4_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL)
+#define ILInterlockedCompareAndExchangeI4_Full(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeI4_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL) */
+
+static IL_INLINE ILUInt32 _ILInterlockedCompareAndExchangeU4_Full(volatile
ILUInt32 *dest,
+
ILUInt32 value,
+
ILUInt32 comparand)
+{
+ ILUInt32 retval;
+
+ ILThreadAtomicStart();
+
+ retval = *dest;
+
+ if(retval == comparand)
+ {
+ *dest = value;
+ }
+
+ ILThreadAtomicEnd();
+
+ return retval;
+}
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4)
+#define ILInterlockedCompareAndExchangeU4(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeU4_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_ACQUIRE)
+#define ILInterlockedCompareAndExchangeU4_Acquire(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeU4_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_RELEASE)
+#define ILInterlockedCompareAndExchangeU4_Release(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeU4_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_FULL)
+#define ILInterlockedCompareAndExchangeU4_Full(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeU4_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU4_FULL) */
+
+static IL_INLINE ILFloat _ILInterlockedCompareAndExchangeR4_Full(volatile
ILFloat *dest,
+
ILFloat value,
+
ILFloat comparand)
+{
+ ILFloat retval;
+
+ ILThreadAtomicStart();
+
+ retval = *dest;
+
+ if(retval == comparand)
+ {
+ *dest = value;
+ }
+
+ ILThreadAtomicEnd();
+
+ return retval;
+}
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4)
+#define ILInterlockedCompareAndExchangeR4(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeR4_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_ACQUIRE)
+#define ILInterlockedCompareAndExchangeR4_Acquire(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeR4_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_RELEASE)
+#define ILInterlockedCompareAndExchangeR4_Release(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeR4_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_FULL)
+#define ILInterlockedCompareAndExchangeR4_Full(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeR4_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER4_FULL) */
+
+static IL_INLINE ILInt32 _ILInterlockedCompareAndExchangeI8_Full(volatile
ILInt64 *dest,
+
ILInt64 value,
+
ILInt64 comparand)
+{
+ ILInt64 retval;
+
+ ILThreadAtomicStart();
+
+ retval = *dest;
+
+ if (retval == comparand)
+ {
+ *dest = value;
+ }
+
+ ILThreadAtomicEnd();
+
+ return retval;
+}
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8)
+#define ILInterlockedCompareAndExchangeI8(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeI8_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_ACQUIRE)
+#define ILInterlockedCompareAndExchangeI8_Acquire(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeI8_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_RELEASE)
+#define ILInterlockedCompareAndExchangeI8_Release(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeI8_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL)
+#define ILInterlockedCompareAndExchangeI8_Full(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeI8_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL) */
+
+static IL_INLINE ILUInt64 _ILInterlockedCompareAndExchangeU8_Full(volatile
ILUInt64 *dest,
+
ILUInt64 value,
+
ILUInt64 comparand)
+{
+ ILUInt64 retval;
+
+ ILThreadAtomicStart();
+
+ retval = *dest;
+
+ if(retval == comparand)
+ {
+ *dest = value;
+ }
+
+ ILThreadAtomicEnd();
+
+ return retval;
+}
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8)
+#define ILInterlockedCompareAndExchangeU8(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeU8_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_ACQUIRE)
+#define ILInterlockedCompareAndExchangeU8_Acquire(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeU8_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_RELEASE)
+#define ILInterlockedCompareAndExchangeU8_Release(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeU8_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_FULL)
+#define ILInterlockedCompareAndExchangeU8_Full(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeU8_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEU8_FULL) */
+
+static IL_INLINE ILDouble _ILInterlockedCompareAndExchangeR8_Full(volatile
ILDouble *dest,
+
ILDouble value,
+
ILDouble comparand)
+{
+ ILDouble retval;
+
+ ILThreadAtomicStart();
+
+ retval = *dest;
+
+ if(retval == comparand)
+ {
+ *dest = value;
+ }
+
+ ILThreadAtomicEnd();
+
+ return retval;
+}
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8)
+#define ILInterlockedCompareAndExchangeR8(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeR8_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_ACQUIRE)
+#define ILInterlockedCompareAndExchangeR8_Acquire(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeR8_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_RELEASE)
+#define ILInterlockedCompareAndExchangeR8_Release(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeR8_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_FULL)
+#define ILInterlockedCompareAndExchangeR8_Full(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeR8_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGER8_FULL) */
+
+static IL_INLINE void *_ILInterlockedCompareAndExchangeP_Full(void * volatile
*dest,
+
void *value,
+
void *comparand)
+{
+ void *retval;
+
+ ILThreadAtomicStart();
+
+ retval = (void *)*dest;
+
+ if(retval == comparand)
+ {
+ *dest = value;
+ }
+
+ ILThreadAtomicEnd();
+
+ return retval;
+}
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP)
+#define ILInterlockedCompareAndExchangeP(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeP_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_ACQUIRE)
+#define ILInterlockedCompareAndExchangeP_Acquire(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeP_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_RELEASE)
+#define ILInterlockedCompareAndExchangeP_Release(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeP_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL)
+#define ILInterlockedCompareAndExchangeP_Full(dest, value, comparand) \
+ _ILInterlockedCompareAndExchangeP_Full((dest), (value),
(comparand))
+#endif /* !defined(IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL) */
+
+static IL_INLINE ILInt32 _ILInterlockedAddI4_Full(volatile ILInt32 *dest,
+
ILInt32 value)
+{
+ ILInt32 retval;
+
+ ILThreadAtomicStart();
+
+ retval = *dest + value;
+ *dest = retval;
+
+ ILThreadAtomicEnd();
+
+ return retval;
+}
+#if !defined(IL_HAVE_INTERLOCKED_ADDI4)
+#define ILInterlockedAddI4(dest, value) \
+ _ILInterlockedAddI4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI4) */
+#if !defined(IL_HAVE_INTERLOCKED_ADDI4_ACQUIRE)
+#define ILInterlockedAddI4_Acquire(dest, value) \
+ _ILInterlockedAddI4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ADDI4_RELEASE)
+#define ILInterlockedAddI4_Release(dest, value) \
+ _ILInterlockedAddI4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_ADDI4_FULL)
+#define ILInterlockedAddI4_Full(dest, value) \
+ _ILInterlockedAddI4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI4_FULL) */
+
+static IL_INLINE ILInt64 _ILInterlockedAddI8_Full(volatile ILInt64 *dest,
+
ILInt64 value)
+{
+ ILInt64 retval;
+
+ ILThreadAtomicStart();
+
+ retval = *dest + value;
+ *dest = retval;
+
+ ILThreadAtomicEnd();
+
+ return retval;
+}
+#if !defined(IL_HAVE_INTERLOCKED_ADDI8)
+#define ILInterlockedAddI8(dest, value) \
+ _ILInterlockedAddI8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI8) */
+#if !defined(IL_HAVE_INTERLOCKED_ADDI8_ACQUIRE)
+#define ILInterlockedAddI8_Acquire(dest, value) \
+ _ILInterlockedAddI8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ADDI8_RELEASE)
+#define ILInterlockedAddI8_Release(dest, value) \
+ _ILInterlockedAddI8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_ADDI8_FULL)
+#define ILInterlockedAddI8_Full(dest, value) \
+ _ILInterlockedAddI8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ADDI8_FULL) */
+
+#if !defined(IL_HAVE_INTERLOCKED_SUBI4)
+#define ILInterlockedSubI4(dest, value) \
+ _ILInterlockedAddI4_Full((dest), -(value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI4) */
+#if !defined(IL_HAVE_INTERLOCKED_SUBI4_ACQUIRE)
+#define ILInterlockedSubI4_Acquire(dest, value) \
+ _ILInterlockedAddI4_Full((dest), -(value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_SUBI4_RELEASE)
+#define ILInterlockedSubI4_Release(dest, value) \
+ _ILInterlockedAddI4_Full((dest), -(value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_SUBI4_FULL)
+#define ILInterlockedSubI4_Full(dest, value) \
+ _ILInterlockedAddI4_Full((dest), -(value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI4_FULL) */
+
+#if !defined(IL_HAVE_INTERLOCKED_SUBI8)
+#define ILInterlockedSubI8(dest, value) \
+ _ILInterlockedAddI8_Full((dest), -(value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI8) */
+#if !defined(IL_HAVE_INTERLOCKED_SUBI8_ACQUIRE)
+#define ILInterlockedSubI8_Acquire(dest, value) \
+ _ILInterlockedAddI8_Full((dest), -(value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_SUBI8_RELEASE)
+#define ILInterlockedSubI8_Release(dest, value) \
+ _ILInterlockedAddI8_Full((dest), -(value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_SUBI8_FULL)
+#define ILInterlockedSubI8_Full(dest, value) \
+ _ILInterlockedAddI8_Full((dest), -(value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_SUBI8_FULL) */
+
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI4)
+#define ILInterlockedIncrementI4(dest) \
+ _ILInterlockedAddI4_Full((dest), 1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI4) */
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_ACQUIRE)
+#define ILInterlockedIncrementI4_Acquire(dest) \
+ _ILInterlockedAddI4_Full((dest), 1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_RELEASE)
+#define ILInterlockedIncrementI4_Release(dest) \
+ _ILInterlockedAddI4_Full((dest), 1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_FULL)
+#define ILInterlockedIncrementI4_Full(dest) \
+ _ILInterlockedAddI4_Full((dest), 1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI4_FULL) */
+
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI8)
+#define ILInterlockedIncrementI8(dest) \
+ _ILInterlockedAddI8_Full((dest), 1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI8) */
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_ACQUIRE)
+#define ILInterlockedIncrementI8_Acquire(dest) \
+ _ILInterlockedAddI8_Full((dest), 1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_RELEASE)
+#define ILInterlockedIncrementI8_Release(dest) \
+ _ILInterlockedAddI8_Full((dest), 1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_FULL)
+#define ILInterlockedIncrementI8_Full(dest) \
+ _ILInterlockedAddI8_Full((dest), 1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_INCREMENTI8_FULL) */
+
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI4)
+#define ILInterlockedDecrementI4(dest) \
+ _ILInterlockedAddI4_Full((dest), -1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI4) */
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_ACQUIRE)
+#define ILInterlockedDecrementI4_Acquire(dest) \
+ _ILInterlockedAddI4_Full((dest), -1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_RELEASE)
+#define ILInterlockedDecrementI4_Release(dest) \
+ _ILInterlockedAddI4_Full((dest), -1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_FULL)
+#define ILInterlockedDecrementI4_Full(dest) \
+ _ILInterlockedAddI4_Full((dest), -1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI4_FULL) */
+
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI8)
+#define ILInterlockedDecrementI8(dest) \
+ _ILInterlockedAddI8_Full((dest), -1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI8) */
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_ACQUIRE)
+#define ILInterlockedDecrementI8_Acquire(dest) \
+ _ILInterlockedAddI8_Full((dest), -1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_RELEASE)
+#define ILInterlockedDecrementI8_Release(dest) \
+ _ILInterlockedAddI8_Full((dest), -1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_FULL)
+#define ILInterlockedDecrementI8_Full(dest) \
+ _ILInterlockedAddI8_Full((dest), -1)
+#endif /* !defined(IL_HAVE_INTERLOCKED_DECREMENTI8_FULL) */
+
+static IL_INLINE void _ILInterlockedAndU4_Full(volatile ILUInt32 *dest,
+
ILUInt32 value)
+{
+ ILThreadAtomicStart();
+
+ *dest &= value;
+
+ ILThreadAtomicEnd();
+}
+#if !defined(IL_HAVE_INTERLOCKED_ANDU4)
+#define ILInterlockedAndU4(dest, value) \
+ _ILInterlockedAndU4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU4) */
+#if !defined(IL_HAVE_INTERLOCKED_ANDU4_ACQUIRE)
+#define ILInterlockedAndU4_Acquire(dest, value) \
+ _ILInterlockedAndU4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ANDU4_RELEASE)
+#define ILInterlockedAndU4_Release(dest, value) \
+ _ILInterlockedAndU4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_ANDU4_FULL)
+#define ILInterlockedAndU4_Full(dest, value) \
+ _ILInterlockedAndU4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU4_FULL) */
+
+static IL_INLINE void _ILInterlockedAndU8_Full(volatile ILUInt64 *dest,
+
ILUInt64 value)
+{
+ ILThreadAtomicStart();
+
+ *dest &= value;
+
+ ILThreadAtomicEnd();
+}
+#if !defined(IL_HAVE_INTERLOCKED_ANDU8)
+#define ILInterlockedAndU8(dest, value) \
+ _ILInterlockedAndU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU8) */
+#if !defined(IL_HAVE_INTERLOCKED_ANDU8_ACQUIRE)
+#define ILInterlockedAndU8_Acquire(dest, value) \
+ _ILInterlockedAndU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ANDU8_RELEASE)
+#define ILInterlockedAndU8_Release(dest, value) \
+ _ILInterlockedAndU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_ANDU8_FULL)
+#define ILInterlockedAndU8_Full(dest, value) \
+ _ILInterlockedAndU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ANDU8_FULL) */
+
+static IL_INLINE void _ILInterlockedOrU4_Full(volatile ILUInt32 *dest,
+
ILUInt32 value)
+{
+ ILThreadAtomicStart();
+
+ *dest |= value;
+
+ ILThreadAtomicEnd();
+}
+#if !defined(IL_HAVE_INTERLOCKED_ORU4)
+#define ILInterlockedOrU4(dest, value) \
+ _ILInterlockedOrU4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU4) */
+#if !defined(IL_HAVE_INTERLOCKED_ORU4_ACQUIRE)
+#define ILInterlockedOrU4_Acquire(dest, value) \
+ _ILInterlockedOrU4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU4_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ORU4_RELEASE)
+#define ILInterlockedOrU4_Release(dest, value) \
+ _ILInterlockedOrU4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU4_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_ORU4_FULL)
+#define ILInterlockedOrU4_Full(dest, value) \
+ _ILInterlockedOrU4_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU4_FULL) */
+
+static IL_INLINE void _ILInterlockedOrU8_Full(volatile ILUInt64 *dest,
+
ILUInt64 value)
+{
+ ILThreadAtomicStart();
+
+ *dest |= value;
+
+ ILThreadAtomicEnd();
+}
+#if !defined(IL_HAVE_INTERLOCKED_ORU8)
+#define ILInterlockedOrU8(dest, value) \
+ _ILInterlockedOrU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU8) */
+#if !defined(IL_HAVE_INTERLOCKED_ORU8_ACQUIRE)
+#define ILInterlockedOrU8_Acquire(dest, value) \
+ _ILInterlockedOrU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU8_ACQUIRE) */
+#if !defined(IL_HAVE_INTERLOCKED_ORU8_RELEASE)
+#define ILInterlockedOrU8_Release(dest, value) \
+ _ILInterlockedOrU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU8_RELEASE) */
+#if !defined(IL_HAVE_INTERLOCKED_ORU8_FULL)
+#define ILInterlockedOrU8_Full(dest, value) \
+ _ILInterlockedOrU8_Full((dest), (value))
+#endif /* !defined(IL_HAVE_INTERLOCKED_ORU8_FULL) */
diff --git a/support/interlocked_arm.h b/support/interlocked_arm.h
index 7a7f0b6..3d205ae 100644
--- a/support/interlocked_arm.h
+++ b/support/interlocked_arm.h
@@ -53,130 +53,6 @@ static IL_INLINE void ILInterlockedMemoryBarrier()
}
#define IL_HAVE_INTERLOCKED_MEMORYBARRIER 1
-/*
- * Load a 32 bit value from a location.
- */
-static IL_INLINE ILInt32 ILInterlockedLoad(const volatile ILInt32 *dest)
-{
- ILInt32 retval;
-
- __asm__ __volatile__
- (
- "\tldr %0, %1\n"
- : "=r" (retval)
- : "m" (*dest)
- );
- return retval;
-}
-#define IL_HAVE_INTERLOCKED_LOAD 1
-
-static IL_INLINE ILInt32 ILInterlockedLoad_Acquire(const volatile ILInt32
*dest)
-{
- ILInt32 retval;
-
- __asm__ __volatile__
- (
- "\tldr %0, %1\n"
- _IL_INTERLOCKED_ARM_MEMORYBARRIER
- : "=r" (retval)
- : "m" (*dest)
- : "memory"
- );
- return retval;
-}
-#define IL_HAVE_INTERLOCKED_LOAD_ACQUIRE 1
-
-/*
- * Load a pointer value from a location.
- */
-static IL_INLINE void *ILInterlockedLoadPointer(void * const volatile *dest)
-{
- void *retval;
-
- __asm__ __volatile__
- (
- "\tldr %0, %1\n"
- : "=r" (retval)
- : "m" (*dest)
- );
- return retval;
-}
-#define IL_HAVE_INTERLOCKED_LOADPOINTER 1
-
-static IL_INLINE void *ILInterlockedLoadPointer_Acquire(void * const volatile
*dest)
-{
- void *retval;
-
- __asm__ __volatile__
- (
- "\tldr %0, %1\n"
- _IL_INTERLOCKED_ARM_MEMORYBARRIER
- : "=r" (retval)
- : "m" (*dest)
- : "memory"
- );
- return retval;
-}
-#define IL_HAVE_INTERLOCKED_LOADPOINTER_ACQUIRE 1
-
-/*
- * Store a 32 bit value to a location.
- */
-static IL_INLINE void ILInterlockedStore(volatile ILInt32 *dest,
-
ILInt32 value)
-{
- __asm__ __volatile__
- (
- "\tstr %1, %0\n"
- : "=m" (*dest)
- : "r" (value)
- );
-}
-#define IL_HAVE_INTERLOCKED_STORE 1
-
-static IL_INLINE void ILInterlockedStore_Release(volatile ILInt32 *dest,
-
ILInt32 value)
-{
- __asm__ __volatile__
- (
- _IL_INTERLOCKED_ARM_MEMORYBARRIER
- "\tstr %1, %0\n"
- : "=m" (*dest)
- : "r" (value)
- : "memory"
- );
-}
-#define IL_HAVE_INTERLOCKED_STORE_RELEASE 1
-
-/*
- * Store a pointer value to a location.
- */
-static IL_INLINE void ILInterlockedStorePointer(void * volatile *dest,
-
void *value)
-{
- __asm__ __volatile__
- (
- "\tstr %1, %0\n"
- : "=m" (*dest)
- : "r" (value)
- );
-}
-#define IL_HAVE_INTERLOCKED_STOREPOINTER 1
-
-static IL_INLINE void ILInterlockedStorePointer_Release(void * volatile *dest,
-
void *value)
-{
- __asm__ __volatile__
- (
- _IL_INTERLOCKED_ARM_MEMORYBARRIER
- "\tstr %1, %0\n"
- : "=m" (*dest)
- : "r" (value)
- : "memory"
- );
-}
-#define IL_HAVE_INTERLOCKED_STOREPOINTER_RELEASE 1
-
#if defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || \
defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6ZK__) || \
defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || \
@@ -190,8 +66,8 @@ static IL_INLINE void ILInterlockedStorePointer_Release(void
* volatile *dest,
/*
* Exchange two 32 bit integers.
*/
-static IL_INLINE ILInt32 ILInterlockedExchange(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt32 ILInterlockedExchangeI4(volatile ILInt32 *dest,
+
ILInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -209,10 +85,10 @@ static IL_INLINE ILInt32 ILInterlockedExchange(volatile
ILInt32 *dest,
);
return retval;
}
-#define IL_HAVE_INTERLOCKED_EXCHANGE 1
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4 1
-static IL_INLINE ILInt32 ILInterlockedExchange_Acquire(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt32 ILInterlockedExchangeI4_Acquire(volatile ILInt32
*dest,
+
ILInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -231,10 +107,10 @@ static IL_INLINE ILInt32
ILInterlockedExchange_Acquire(volatile ILInt32 *dest,
);
return retval;
}
-#define IL_HAVE_INTERLOCKED_EXCHANGE_ACQUIRE 1
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4_ACQUIRE 1
-static IL_INLINE ILInt32 ILInterlockedExchange_Release(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt32 ILInterlockedExchangeI4_Release(volatile ILInt32
*dest,
+
ILInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -253,10 +129,10 @@ static IL_INLINE ILInt32
ILInterlockedExchange_Release(volatile ILInt32 *dest,
);
return retval;
}
-#define IL_HAVE_INTERLOCKED_EXCHANGE_RELEASE 1
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4_RELEASE 1
-static IL_INLINE ILInt32 ILInterlockedExchange_Full(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt32 ILInterlockedExchangeI4_Full(volatile ILInt32 *dest,
+
ILInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -276,13 +152,13 @@ static IL_INLINE ILInt32
ILInterlockedExchange_Full(volatile ILInt32 *dest,
);
return retval;
}
-#define IL_HAVE_INTERLOCKED_EXCHANGE_FULL 1
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL 1
/*
* Exchange pointers.
*/
-static IL_INLINE void *ILInterlockedExchangePointers(void * volatile *dest,
-
void *value)
+static IL_INLINE void *ILInterlockedExchangeP(void * volatile *dest,
+
void *value)
{
void *retval;
ILInt32 state;
@@ -301,10 +177,10 @@ static IL_INLINE void *ILInterlockedExchangePointers(void
* volatile *dest,
return retval;
}
-#define IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS 1
+#define IL_HAVE_INTERLOCKED_EXCHANGEP 1
-static IL_INLINE void *ILInterlockedExchangePointers_Acquire(void * volatile
*dest,
-
void *value)
+static IL_INLINE void *ILInterlockedExchangeP_Acquire(void * volatile *dest,
+
void *value)
{
void *retval;
ILInt32 state;
@@ -324,10 +200,10 @@ static IL_INLINE void
*ILInterlockedExchangePointers_Acquire(void * volatile *de
return retval;
}
-#define IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_ACQUIRE 1
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_ACQUIRE 1
-static IL_INLINE void *ILInterlockedExchangePointers_Release(void * volatile
*dest,
-
void *value)
+static IL_INLINE void *ILInterlockedExchangeP_Release(void * volatile *dest,
+
void *value)
{
void *retval;
ILInt32 state;
@@ -347,10 +223,10 @@ static IL_INLINE void
*ILInterlockedExchangePointers_Release(void * volatile *de
return retval;
}
-#define IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_RELEASE 1
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_RELEASE 1
-static IL_INLINE void *ILInterlockedExchangePointers_Full(void * volatile
*dest,
-
void *value)
+static IL_INLINE void *ILInterlockedExchangeP_Full(void * volatile *dest,
+
void *value)
{
void *retval;
ILInt32 state;
@@ -371,14 +247,14 @@ static IL_INLINE void
*ILInterlockedExchangePointers_Full(void * volatile *dest,
return retval;
}
-#define IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_FULL 1
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_FULL 1
/*
* Compare and exchange two 32bit integers.
*/
-static IL_INLINE ILInt32 ILInterlockedCompareAndExchange(volatile ILInt32
*dest,
-
ILInt32 value,
-
ILInt32 comparand)
+static IL_INLINE ILInt32 ILInterlockedCompareAndExchangeI4(volatile ILInt32
*dest,
+
ILInt32 value,
+
ILInt32 comparand)
{
ILInt32 retval;
ILInt32 state;
@@ -398,11 +274,11 @@ static IL_INLINE ILInt32
ILInterlockedCompareAndExchange(volatile ILInt32 *dest,
return retval;
}
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE 1
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4 1
-static IL_INLINE ILInt32 ILInterlockedCompareAndExchange_Acquire(volatile
ILInt32 *dest,
-
ILInt32 value,
-
ILInt32 comparand)
+static IL_INLINE ILInt32 ILInterlockedCompareAndExchangeI4_Acquire(volatile
ILInt32 *dest,
+
ILInt32 value,
+
ILInt32 comparand)
{
ILInt32 retval;
ILInt32 state;
@@ -423,11 +299,11 @@ static IL_INLINE ILInt32
ILInterlockedCompareAndExchange_Acquire(volatile ILInt3
return retval;
}
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_ACQUIRE 1
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_ACQUIRE 1
-static IL_INLINE ILInt32 ILInterlockedCompareAndExchange_Release(volatile
ILInt32 *dest,
-
ILInt32 value,
-
ILInt32 comparand)
+static IL_INLINE ILInt32 ILInterlockedCompareAndExchangeI4_Release(volatile
ILInt32 *dest,
+
ILInt32 value,
+
ILInt32 comparand)
{
ILInt32 retval;
ILInt32 state;
@@ -448,11 +324,11 @@ static IL_INLINE ILInt32
ILInterlockedCompareAndExchange_Release(volatile ILInt3
return retval;
}
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_RELEASE 1
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_RELEASE 1
-static IL_INLINE ILInt32 ILInterlockedCompareAndExchange_Full(volatile ILInt32
*dest,
-
ILInt32 value,
-
ILInt32 comparand)
+static IL_INLINE ILInt32 ILInterlockedCompareAndExchangeI4_Full(volatile
ILInt32 *dest,
+
ILInt32 value,
+
ILInt32 comparand)
{
ILInt32 retval;
ILInt32 state;
@@ -474,14 +350,14 @@ static IL_INLINE ILInt32
ILInterlockedCompareAndExchange_Full(volatile ILInt32 *
return retval;
}
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_FULL 1
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL 1
/*
* Compare and exchange two pointers.
*/
-static IL_INLINE void *ILInterlockedCompareAndExchangePointers(void * volatile
*dest,
-
void *value,
-
void *comparand)
+static IL_INLINE void *ILInterlockedCompareAndExchangeP(void * volatile *dest,
+
void *value,
+
void *comparand)
{
void *retval;
ILInt32 state;
@@ -501,11 +377,11 @@ static IL_INLINE void
*ILInterlockedCompareAndExchangePointers(void * volatile *
return retval;
}
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS 1
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP 1
-static IL_INLINE void *ILInterlockedCompareAndExchangePointers_Acquire(void *
volatile *dest,
-
void *value,
-
void *comparand)
+static IL_INLINE void *ILInterlockedCompareAndExchangeP_Acquire(void *
volatile *dest,
+
void *value,
+
void *comparand)
{
void *retval;
ILInt32 state;
@@ -526,11 +402,11 @@ static IL_INLINE void
*ILInterlockedCompareAndExchangePointers_Acquire(void * vo
return retval;
}
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_ACQUIRE 1
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_ACQUIRE 1
-static IL_INLINE void *ILInterlockedCompareAndExchangePointers_Release(void *
volatile *dest,
-
void *value,
-
void *comparand)
+static IL_INLINE void *ILInterlockedCompareAndExchangeP_Release(void *
volatile *dest,
+
void *value,
+
void *comparand)
{
void *retval;
ILInt32 state;
@@ -551,11 +427,11 @@ static IL_INLINE void
*ILInterlockedCompareAndExchangePointers_Release(void * vo
return retval;
}
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_RELEASE 1
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_RELEASE 1
-static IL_INLINE void *ILInterlockedCompareAndExchangePointers_Full(void *
volatile *dest,
-
void *value,
-
void *comparand)
+static IL_INLINE void *ILInterlockedCompareAndExchangeP_Full(void * volatile
*dest,
+
void *value,
+
void *comparand)
{
void *retval;
ILInt32 state;
@@ -577,13 +453,13 @@ static IL_INLINE void
*ILInterlockedCompareAndExchangePointers_Full(void * volat
return retval;
}
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_FULL 1
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL 1
/*
* Add two 32 bit integer values.
*/
-static IL_INLINE ILInt32 ILInterlockedAdd(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt32 ILInterlockedAddI4(volatile ILInt32 *dest,
+
ILInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -603,10 +479,10 @@ static IL_INLINE ILInt32 ILInterlockedAdd(volatile
ILInt32 *dest,
return retval;
}
-#define IL_HAVE_INTERLOCKED_ADD 1
+#define IL_HAVE_INTERLOCKED_ADDI4 1
-static IL_INLINE ILInt32 ILInterlockedAdd_Acquire(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt32 ILInterlockedAddI4_Acquire(volatile ILInt32 *dest,
+
ILInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -627,10 +503,10 @@ static IL_INLINE ILInt32
ILInterlockedAdd_Acquire(volatile ILInt32 *dest,
return retval;
}
-#define IL_HAVE_INTERLOCKED_ADD_ACQUIRE 1
+#define IL_HAVE_INTERLOCKED_ADDI4_ACQUIRE 1
-static IL_INLINE ILInt32 ILInterlockedAdd_Release(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt32 ILInterlockedAddI4_Release(volatile ILInt32 *dest,
+
ILInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -651,10 +527,10 @@ static IL_INLINE ILInt32
ILInterlockedAdd_Release(volatile ILInt32 *dest,
return retval;
}
-#define IL_HAVE_INTERLOCKED_ADD_RELEASE 1
+#define IL_HAVE_INTERLOCKED_ADDI4_RELEASE 1
-static IL_INLINE ILInt32 ILInterlockedAdd_Full(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt32 ILInterlockedAddI4_Full(volatile ILInt32 *dest,
+
ILInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -676,13 +552,13 @@ static IL_INLINE ILInt32 ILInterlockedAdd_Full(volatile
ILInt32 *dest,
return retval;
}
-#define IL_HAVE_INTERLOCKED_ADD_FULL 1
+#define IL_HAVE_INTERLOCKED_ADDI4_FULL 1
/*
* Subtract two 32 bit integer values.
*/
-static IL_INLINE ILInt32 ILInterlockedSub(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt32 ILInterlockedSubI4(volatile ILInt32 *dest,
+
ILInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -702,10 +578,10 @@ static IL_INLINE ILInt32 ILInterlockedSub(volatile
ILInt32 *dest,
return retval;
}
-#define IL_HAVE_INTERLOCKED_SUB 1
+#define IL_HAVE_INTERLOCKED_SUBI4 1
-static IL_INLINE ILInt32 ILInterlockedSub_Acquire(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt32 ILInterlockedSubI4_Acquire(volatile ILInt32 *dest,
+
ILInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -726,10 +602,10 @@ static IL_INLINE ILInt32
ILInterlockedSub_Acquire(volatile ILInt32 *dest,
return retval;
}
-#define IL_HAVE_INTERLOCKED_SUB_ACQUIRE 1
+#define IL_HAVE_INTERLOCKED_SUBI4_ACQUIRE 1
-static IL_INLINE ILInt32 ILInterlockedSub_Release(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt32 ILInterlockedSubI4_Release(volatile ILInt32 *dest,
+
ILInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -750,10 +626,10 @@ static IL_INLINE ILInt32
ILInterlockedSub_Release(volatile ILInt32 *dest,
return retval;
}
-#define IL_HAVE_INTERLOCKED_SUB_RELEASE 1
+#define IL_HAVE_INTERLOCKED_SUBI4_RELEASE 1
-static IL_INLINE ILInt32 ILInterlockedSub_Full(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt32 ILInterlockedSubI4_Full(volatile ILInt32 *dest,
+
ILInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -775,12 +651,13 @@ static IL_INLINE ILInt32 ILInterlockedSub_Full(volatile
ILInt32 *dest,
return retval;
}
-#define IL_HAVE_INTERLOCKED_SUB_FULL 1
+#define IL_HAVE_INTERLOCKED_SUBI4_FULL 1
/*
* 32bit bitwise AND
*/
-static IL_INLINE void ILInterlockedAnd(volatile ILUInt32 *dest, ILUInt32 value)
+static IL_INLINE void ILInterlockedAndU4(volatile ILUInt32 *dest,
+
ILUInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -798,10 +675,10 @@ static IL_INLINE void ILInterlockedAnd(volatile ILUInt32
*dest, ILUInt32 value)
: "cc"
);
}
-#define IL_HAVE_INTERLOCKED_AND 1
+#define IL_HAVE_INTERLOCKED_ANDU4 1
-static IL_INLINE void ILInterlockedAnd_Acquire(volatile ILUInt32 *dest,
-
ILUInt32 value)
+static IL_INLINE void ILInterlockedAndU4_Acquire(volatile ILUInt32 *dest,
+
ILUInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -820,10 +697,10 @@ static IL_INLINE void ILInterlockedAnd_Acquire(volatile
ILUInt32 *dest,
: "memory", "cc"
);
}
-#define IL_HAVE_INTERLOCKED_AND_ACQUIRE 1
+#define IL_HAVE_INTERLOCKED_ANDU4_ACQUIRE 1
-static IL_INLINE void ILInterlockedAnd_Release(volatile ILUInt32 *dest,
-
ILUInt32 value)
+static IL_INLINE void ILInterlockedAndU4_Release(volatile ILUInt32 *dest,
+
ILUInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -842,10 +719,10 @@ static IL_INLINE void ILInterlockedAnd_Release(volatile
ILUInt32 *dest,
: "memory", "cc"
);
}
-#define IL_HAVE_INTERLOCKED_AND_RELEASE 1
+#define IL_HAVE_INTERLOCKED_ANDU4_RELEASE 1
-static IL_INLINE void ILInterlockedAnd_Full(volatile ILUInt32 *dest,
-
ILUInt32 value)
+static IL_INLINE void ILInterlockedAndU4_Full(volatile ILUInt32 *dest,
+
ILUInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -865,12 +742,13 @@ static IL_INLINE void ILInterlockedAnd_Full(volatile
ILUInt32 *dest,
: "memory", "cc"
);
}
-#define IL_HAVE_INTERLOCKED_AND_FULL 1
+#define IL_HAVE_INTERLOCKED_ANDU4_FULL 1
/*
* 32bit bitwise OR
*/
-static IL_INLINE void ILInterlockedOr(volatile ILUInt32 *dest, ILUInt32 value)
+static IL_INLINE void ILInterlockedOrU4(volatile ILUInt32 *dest,
+
ILUInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -888,9 +766,10 @@ static IL_INLINE void ILInterlockedOr(volatile ILUInt32
*dest, ILUInt32 value)
: "cc"
);
}
-#define IL_HAVE_INTERLOCKED_OR 1
+#define IL_HAVE_INTERLOCKED_ORU4 1
-static IL_INLINE void ILInterlockedOr_Acquire(volatile ILUInt32 *dest,
ILUInt32 value)
+static IL_INLINE void ILInterlockedOrU4_Acquire(volatile ILUInt32 *dest,
+
ILUInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -909,9 +788,10 @@ static IL_INLINE void ILInterlockedOr_Acquire(volatile
ILUInt32 *dest, ILUInt32
: "memory", "cc"
);
}
-#define IL_HAVE_INTERLOCKED_OR_ACQUIRE 1
+#define IL_HAVE_INTERLOCKED_ORU4_ACQUIRE 1
-static IL_INLINE void ILInterlockedOr_Release(volatile ILUInt32 *dest,
ILUInt32 value)
+static IL_INLINE void ILInterlockedOrU4_Release(volatile ILUInt32 *dest,
+
ILUInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -930,9 +810,10 @@ static IL_INLINE void ILInterlockedOr_Release(volatile
ILUInt32 *dest, ILUInt32
: "memory", "cc"
);
}
-#define IL_HAVE_INTERLOCKED_OR_RELEASE 1
+#define IL_HAVE_INTERLOCKED_ORU4_RELEASE 1
-static IL_INLINE void ILInterlockedOr_Full(volatile ILUInt32 *dest, ILUInt32
value)
+static IL_INLINE void ILInterlockedOrU4_Full(volatile ILUInt32 *dest,
+
ILUInt32 value)
{
ILInt32 retval;
ILInt32 state;
@@ -952,15 +833,15 @@ static IL_INLINE void ILInterlockedOr_Full(volatile
ILUInt32 *dest, ILUInt32 val
: "memory", "cc"
);
}
-#define IL_HAVE_INTERLOCKED_OR_FULL 1
+#define IL_HAVE_INTERLOCKED_ORU4_FULL 1
#else /* __ARM_ARCH__ <= 5 || __ARM_ARCH_6M__ */
/*
* Exchange two 32 bit integers.
*/
-static IL_INLINE ILInt32 ILInterlockedExchange_Full(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt32 ILInterlockedExchangeI4_Full(volatile ILInt32 *dest,
+
ILInt32 value)
{
ILInt32 retval;
@@ -974,13 +855,13 @@ static IL_INLINE ILInt32
ILInterlockedExchange_Full(volatile ILInt32 *dest,
return retval;
}
-#define IL_HAVE_INTERLOCKED_EXCHANGE_FULL 1
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL 1
/*
* Exchange pointers.
*/
-static IL_INLINE void *ILInterlockedExchangePointers_Full(void * volatile
*dest,
-
void *value)
+static IL_INLINE void *ILInterlockedExchangeP_Full(void * volatile *dest,
+
void *value)
{
void *retval;
@@ -994,7 +875,7 @@ static IL_INLINE void
*ILInterlockedExchangePointers_Full(void * volatile *dest,
return retval;
}
-#define IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_FULL 1
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_FULL 1
#endif /* __ARM_ARCH__ <= 5 || __ARM_ARCH_6M__ */
diff --git a/support/interlocked_x86.h b/support/interlocked_x86.h
index d9847a0..993533c 100644
--- a/support/interlocked_x86.h
+++ b/support/interlocked_x86.h
@@ -53,7 +53,7 @@ static IL_INLINE void ILInterlockedMemoryBarrier()
/*
* Load a 32 bit value from a location with acquire semantics.
*/
-static IL_INLINE ILInt32 ILInterlockedLoad_Acquire(const volatile ILInt32
*dest)
+static IL_INLINE ILInt32 ILInterlockedLoadI4_Acquire(const volatile ILInt32
*dest)
{
ILInt32 retval;
@@ -68,12 +68,12 @@ static IL_INLINE ILInt32 ILInterlockedLoad_Acquire(const
volatile ILInt32 *dest)
return retval;
}
-#define IL_HAVE_INTERLOCKED_LOAD_ACQUIRE
+#define IL_HAVE_INTERLOCKED_LOADI3_ACQUIRE
/*
* Load a pointer value from a location with acquire semantics.
*/
-static IL_INLINE void * ILInterlockedLoadPointer_Acquire(void * const volatile
*dest)
+static IL_INLINE void * ILInterlockedLoadP_Acquire(void * const volatile *dest)
{
void *retval;
@@ -92,12 +92,12 @@ static IL_INLINE void *
ILInterlockedLoadPointer_Acquire(void * const volatile *
return retval;
}
-#define IL_HAVE_INTERLOCKED_LOADPOINTER_ACQUIRE
+#define IL_HAVE_INTERLOCKED_LOADP_ACQUIRE
/*
* Store a 32 bit value to a location with release semantics.
*/
-static IL_INLINE void ILInterlockedStore_Release(volatile ILInt32 *dest,
+static IL_INLINE void ILInterlockedStoreI4_Release(volatile ILInt32 *dest,
ILInt32 value)
{
__asm__ __volatile__
@@ -109,13 +109,13 @@ static IL_INLINE void ILInterlockedStore_Release(volatile
ILInt32 *dest,
: "memory"
);
}
-#define IL_HAVE_INTERLOCKED_STORE_RELEASE 1
+#define IL_HAVE_INTERLOCKED_STOREI4_RELEASE 1
/*
* Store a pointer value to a location with release semantics.
*/
-static IL_INLINE void ILInterlockedStorePointer_Release(void * volatile *dest,
-
void *value)
+static IL_INLINE void ILInterlockedStoreP_Release(void * volatile *dest,
+
void *value)
{
__asm__ __volatile__
(
@@ -130,13 +130,13 @@ static IL_INLINE void
ILInterlockedStorePointer_Release(void * volatile *dest,
: "memory"
);
}
-#define IL_HAVE_INTERLOCKED_STOREPOINTER_RELEASE 1
+#define IL_HAVE_INTERLOCKED_STOREP_RELEASE 1
/*
* Exchange two 32 bit integers.
*/
-static IL_INLINE ILInt32 ILInterlockedExchange_Full(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt32 ILInterlockedExchangeI4_Full(volatile ILInt32 *dest,
+
ILInt32 value)
{
ILInt32 retval;
@@ -153,13 +153,13 @@ static IL_INLINE ILInt32
ILInterlockedExchange_Full(volatile ILInt32 *dest,
return retval;
}
-#define IL_HAVE_INTERLOCKED_EXCHANGE_FULL 1
+#define IL_HAVE_INTERLOCKED_EXCHANGEI4_FULL 1
/*
* Exchange pointers.
*/
-static IL_INLINE void *ILInterlockedExchangePointers_Full(void * volatile
*dest,
-
void *value)
+static IL_INLINE void *ILInterlockedExchangeP_Full(void * volatile *dest,
+
void *value)
{
void *retval;
@@ -180,37 +180,16 @@ static IL_INLINE void
*ILInterlockedExchangePointers_Full(void * volatile *dest,
return retval;
}
-#define IL_HAVE_INTERLOCKED_EXCHANGEPOINTERS_FULL 1
-
-/*
- * Compare and exchange two 32bit integers.
- */
-static IL_INLINE ILInt32 ILInterlockedCompareAndExchange(volatile ILInt32
*dest,
-
ILInt32 value,
-
ILInt32 comparand)
-{
- ILInt32 retval;
-
- __asm__ __volatile__
- (
- "lock;"
- "cmpxchgl %2, %0"
- : "=m" (*dest), "=a" (retval)
- : "r" (value), "m" (*dest), "a" (comparand)
- );
-
- return retval;
-}
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE 1
+#define IL_HAVE_INTERLOCKED_EXCHANGEP_FULL 1
/*
* Compare and exchange two 32bit integers with full semantics.
* x86 has full semantics with the lock prefix but gcc might move memory
* loads before this statement so we have to add the "memory" clobber here.
*/
-static IL_INLINE ILInt32 ILInterlockedCompareAndExchange_Full(volatile ILInt32
*dest,
-
ILInt32 value,
-
ILInt32 comparand)
+static IL_INLINE ILInt32 ILInterlockedCompareAndExchangeI4_Full(volatile
ILInt32 *dest,
+
ILInt32 value,
+
ILInt32 comparand)
{
ILInt32 retval;
@@ -225,14 +204,16 @@ static IL_INLINE ILInt32
ILInterlockedCompareAndExchange_Full(volatile ILInt32 *
return retval;
}
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGE_FULL 1
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI4_FULL 1
/*
- * Compare and exchange two pointers.
+ * Compare and exchange two pointers with full semantics.
+ * x86 has full semantics with the lock prefix but gcc might move memory
+ * loads before this statement so we have to add the "memory" clobber here.
*/
-static IL_INLINE void *ILInterlockedCompareAndExchangePointers(void * volatile
*dest,
-
void *value,
-
void *comparand)
+static IL_INLINE void *ILInterlockedCompareAndExchangeP_Full(void * volatile
*dest,
+
void *value,
+
void *comparand)
{
void *retval;
@@ -246,29 +227,29 @@ static IL_INLINE void
*ILInterlockedCompareAndExchangePointers(void * volatile *
#endif
: "=m" (*dest), "=a" (retval)
: "r" (value), "m" (*dest), "a" (comparand)
+ : "memory"
);
return retval;
}
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS 1
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEP_FULL 1
+#if defined(__x86_64__)
/*
- * Compare and exchange two pointers.
+ * Compare and exchange two 64bit integers with full semantics.
+ * x86 has full semantics with the lock prefix but gcc might move memory
+ * loads before this statement so we have to add the "memory" clobber here.
*/
-static IL_INLINE void *ILInterlockedCompareAndExchangePointers_Full(void *
volatile *dest,
-
void *value,
-
void *comparand)
+static IL_INLINE ILInt64 ILInterlockedCompareAndExchangeI8_Full(volatile
ILInt64 *dest,
+
ILInt64 value,
+
ILInt64 comparand)
{
- void *retval;
+ ILInt32 retval;
__asm__ __volatile__
(
"lock;"
-#if defined(__x86_64__)
- "cmpxchgq %2, %0;"
-#else
- "cmpxchgl %2, %0;"
-#endif
+ "cmpxchgq %2, %0"
: "=m" (*dest), "=a" (retval)
: "r" (value), "m" (*dest), "a" (comparand)
: "memory"
@@ -276,13 +257,14 @@ static IL_INLINE void
*ILInterlockedCompareAndExchangePointers_Full(void * volat
return retval;
}
-#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEPOINTERS_FULL 1
+#define IL_HAVE_INTERLOCKED_COMPAREANDEXCHANGEI8_FULL 1
+#endif
/*
* Add two 32 bit integer values.
*/
-static IL_INLINE ILInt32 ILInterlockedAdd_Full(volatile ILInt32 *dest,
-
ILInt32 value)
+static IL_INLINE ILInt32 ILInterlockedAddI4_Full(volatile ILInt32 *dest,
+
ILInt32 value)
{
ILInt32 retval;
@@ -297,13 +279,13 @@ static IL_INLINE ILInt32 ILInterlockedAdd_Full(volatile
ILInt32 *dest,
return retval + value;
}
-#define IL_HAVE_INTERLOCKED_ADD_FULL 1
+#define IL_HAVE_INTERLOCKED_ADDI4_FULL 1
/*
* 32bit bitwise AND
*/
-static IL_INLINE void ILInterlockedAnd_Full(volatile ILUInt32 *dest,
-
ILUInt32 value)
+static IL_INLINE void ILInterlockedAndU4_Full(volatile ILUInt32 *dest,
+
ILUInt32 value)
{
__asm__ __volatile__
(
@@ -313,13 +295,13 @@ static IL_INLINE void ILInterlockedAnd_Full(volatile
ILUInt32 *dest,
: "er" (value), "m" (*dest)
: "memory");
}
-#define IL_HAVE_INTERLOCKED_AND_FULL 1
+#define IL_HAVE_INTERLOCKED_ANDU4_FULL 1
/*
* 32bit bitwise OR
*/
-static IL_INLINE void ILInterlockedOr_Full(volatile ILUInt32 *dest,
-
ILUInt32 value)
+static IL_INLINE void ILInterlockedOrU4_Full(volatile ILUInt32 *dest,
+
ILUInt32 value)
{
__asm__ __volatile__
(
@@ -329,7 +311,7 @@ static IL_INLINE void ILInterlockedOr_Full(volatile
ILUInt32 *dest,
: "er" (value), "m" (*dest)
: "memory");
}
-#define IL_HAVE_INTERLOCKED_OR_FULL 1
+#define IL_HAVE_INTERLOCKED_ORU4_FULL 1
#endif /* defined(__GNUC__) */
diff --git a/support/monitor.c b/support/monitor.c
index 3c285ab..96c2d4d 100644
--- a/support/monitor.c
+++ b/support/monitor.c
@@ -351,8 +351,7 @@ static int MonitorPredicate(void *mon)
monitor = (ILMonitor *)mon;
thread = _ILThreadGetSelf();
- ILInterlockedCompareAndExchangePointers((void **)&(monitor->owner),
-
thread, 0);
+ ILInterlockedCompareAndExchangeP((void **)&(monitor->owner), thread, 0);
return (monitor->owner == thread);
}
diff --git a/tests/test_thread.c b/tests/test_thread.c
index 52e765b..b1c394f 100755
--- a/tests/test_thread.c
+++ b/tests/test_thread.c
@@ -1108,26 +1108,26 @@ static void interlocked_load(void *arg)
haveError = 0;
value = 1;
- if(ILInterlockedLoad(&value) != 1)
+ if(ILInterlockedLoadI4(&value) != 1)
{
haveError = 1;
- ILUnitFailMessage("Incorrect return value of
ILInterlockedLoad");
+ ILUnitFailMessage("Incorrect return value of
ILInterlockedLoadI4");
}
- if(ILInterlockedLoad_Acquire(&value) != 1)
+ if(ILInterlockedLoadI4_Acquire(&value) != 1)
{
haveError = 1;
- ILUnitFailMessage("Incorrect return value of
ILInterlockedLoad_Acquire");
+ ILUnitFailMessage("Incorrect return value of
ILInterlockedLoadI4_Acquire");
}
ptrValue = (void *)1;
- if(ILInterlockedLoadPointer(&ptrValue) != (void *)1)
+ if(ILInterlockedLoadP(&ptrValue) != (void *)1)
{
haveError = 1;
- ILUnitFailMessage("Incorrect return value of
ILInterlockedLoadPointer");
+ ILUnitFailMessage("Incorrect return value of
ILInterlockedLoadP");
}
- if(ILInterlockedLoadPointer_Acquire(&ptrValue) != (void *)1)
+ if(ILInterlockedLoadP_Acquire(&ptrValue) != (void *)1)
{
haveError = 1;
- ILUnitFailMessage("Incorrect return value of
ILInterlockedLoadPointer_Acquire");
+ ILUnitFailMessage("Incorrect return value of
ILInterlockedLoadP_Acquire");
}
if(haveError)
{
@@ -1143,30 +1143,30 @@ static void interlocked_store(void *arg)
haveError = 0;
value = 1;
- ILInterlockedStore(&value, 2);
+ ILInterlockedStoreI4(&value, 2);
if(value != 2)
{
haveError = 1;
- ILUnitFailMessage("ILInterlockedStore doesn't store the correct
value");
+ ILUnitFailMessage("ILInterlockedStoreI4 doesn't store the
correct value");
}
- ILInterlockedStore_Release(&value, 3);
+ ILInterlockedStoreI4_Release(&value, 3);
if(value != 3)
{
haveError = 1;
- ILUnitFailMessage("ILInterlockedStore_Release doesn't store the
correct value");
+ ILUnitFailMessage("ILInterlockedStoreI4_Release doesn't store
the correct value");
}
ptrValue = (void *)1;
- ILInterlockedStorePointer(&ptrValue, (void *)2);
+ ILInterlockedStoreP(&ptrValue, (void *)2);
if(ptrValue != (void *)2)
{
haveError = 1;
- ILUnitFailMessage("ILInterlockedStorePointer doesn't store the
correct value");
+ ILUnitFailMessage("ILInterlockedStoreP doesn't store the
correct value");
}
- ILInterlockedStorePointer_Release(&ptrValue, (void *)3);
+ ILInterlockedStoreP_Release(&ptrValue, (void *)3);
if(ptrValue != (void *)3)
{
haveError = 1;
- ILUnitFailMessage("ILInterlockedStorePointer_Release doesn't
store the correct value");
+ ILUnitFailMessage("ILInterlockedStoreP_Release doesn't store
the correct value");
}
if(haveError)
{
@@ -1182,17 +1182,17 @@ static void interlocked_exchange(void *arg)
haveError = 0;
value = 0;
- result = ILInterlockedExchange(&value, 5);
+ result = ILInterlockedExchangeI4(&value, 5);
if(result != 0)
{
haveError = 1;
- ILUnitFailMessage("Incorrect return value of
ILInterlockedExchange");
+ ILUnitFailMessage("Incorrect return value of
ILInterlockedExchangeI4");
ILUnitFailMessage("Expected 0 but was %i", result);
}
if(value != 5)
{
haveError = 1;
- ILUnitFailMessage("Incorrect value set in
ILInterlockedExchange");
+ ILUnitFailMessage("Incorrect value set in
ILInterlockedExchangeI4");
ILUnitFailMessage("Expected 5 but was %i", value);
}
if(haveError)
@@ -1209,17 +1209,17 @@ static void interlocked_exchange_pointers(void *arg)
haveError = 0;
value = 0;
- result = ILInterlockedExchangePointers(&value, (void *)5);
+ result = ILInterlockedExchangeP(&value, (void *)5);
if(result != 0)
{
haveError = 1;
- ILUnitFailMessage("Incorrect return value of
ILInterlockedExchangePointers");
+ ILUnitFailMessage("Incorrect return value of
ILInterlockedExchangeP");
ILUnitFailMessage("Expected 0 but was %p", result);
}
if(value != (void *)5)
{
haveError = 1;
- ILUnitFailMessage("Incorrect value set in
ILInterlockedExchangePointers");
+ ILUnitFailMessage("Incorrect value set in
ILInterlockedExchangeP");
ILUnitFailMessage("Expected 5 but was %p", value);
}
if(haveError)
@@ -1236,17 +1236,17 @@ static void interlocked_compare_and_exchange(void *arg)
haveError = 0;
value = 0;
- result = ILInterlockedCompareAndExchange(&value, 5, 0);
+ result = ILInterlockedCompareAndExchangeI4(&value, 5, 0);
if(result != 0)
{
haveError = 1;
- ILUnitFailMessage("Incorrect return value of
ILInterlockedCompareAndExchange");
+ ILUnitFailMessage("Incorrect return value of
ILInterlockedCompareAndExchangeI4");
ILUnitFailMessage("Expected 0 but was %i", result);
}
if(value != 5)
{
haveError = 1;
- ILUnitFailMessage("Incorrect value set in
ILInterlockedCompareAndExchange");
+ ILUnitFailMessage("Incorrect value set in
ILInterlockedCompareAndExchangeI4");
ILUnitFailMessage("Expected 5 but was %i", value);
}
if(haveError)
@@ -1263,17 +1263,17 @@ static void interlocked_compare_and_exchange_fail(void
*arg)
haveError = 0;
value = 0;
- result = ILInterlockedCompareAndExchange(&value, 5, 1);
+ result = ILInterlockedCompareAndExchangeI4(&value, 5, 1);
if(result != 0)
{
haveError = 1;
- ILUnitFailMessage("Incorrect return value of
ILInterlockedCompareAndExchange");
+ ILUnitFailMessage("Incorrect return value of
ILInterlockedCompareAndExchangeI4");
ILUnitFailMessage("Expected 0 but was %i", result);
}
if(value != 0)
{
haveError = 1;
- ILUnitFailMessage("Incorrect value set in
ILInterlockedCompareAndExchange");
+ ILUnitFailMessage("Incorrect value set in
ILInterlockedCompareAndExchangeI4");
ILUnitFailMessage("Expected 0 but was %i", value);
}
if(haveError)
@@ -1290,17 +1290,17 @@ static void
interlocked_compare_and_exchange_pointers(void *arg)
haveError = 0;
value = 0;
- result = ILInterlockedCompareAndExchangePointers(&value, (void *)5,
(void *)0);
+ result = ILInterlockedCompareAndExchangeP(&value, (void *)5, (void *)0);
if(result != 0)
{
haveError = 1;
- ILUnitFailMessage("Incorrect return value of
ILInterlockedCompareAndExchangePointers");
+ ILUnitFailMessage("Incorrect return value of
ILInterlockedCompareAndExchangeP");
ILUnitFailMessage("Expected 0 but was %p", result);
}
if(value != (void *)5)
{
haveError = 1;
- ILUnitFailMessage("Incorrect value set in
ILInterlockedCompareAndExchangePointers");
+ ILUnitFailMessage("Incorrect value set in
ILInterlockedCompareAndExchangeP");
ILUnitFailMessage("Expected 5 but was %p", value);
}
if(haveError)
@@ -1317,17 +1317,17 @@ static void
interlocked_compare_and_exchange_pointers_fail(void *arg)
haveError = 0;
value = 0;
- result = ILInterlockedCompareAndExchangePointers(&value, (void *)5,
(void *)1);
+ result = ILInterlockedCompareAndExchangeP(&value, (void *)5, (void *)1);
if(result != 0)
{
haveError = 1;
- ILUnitFailMessage("Incorrect return value of
ILInterlockedCompareAndExchangePointers");
+ ILUnitFailMessage("Incorrect return value of
ILInterlockedCompareAndExchangeP");
ILUnitFailMessage("Expected 0 but was %p", result);
}
if(value != (void *)0)
{
haveError = 1;
- ILUnitFailMessage("Incorrect value set in
ILInterlockedCompareAndExchangePointers");
+ ILUnitFailMessage("Incorrect value set in
ILInterlockedCompareAndExchangeP");
ILUnitFailMessage("Expected 5 but was %p", value);
}
if(haveError)
@@ -1342,10 +1342,10 @@ static void interlocked_increment(void *arg)
ILInt32 result;
value = 0;
- result = ILInterlockedIncrement(&value);
+ result = ILInterlockedIncrementI4(&value);
if(result != 1)
{
- ILUnitFailed("ILInterlockedIncrement returned the wrong
result.\n"
+ ILUnitFailed("ILInterlockedIncrementI4 returned the wrong
result.\n"
"Expected: 1 bus was %i\n", result);
}
ILUnitAssert(value == 1);
@@ -1357,10 +1357,10 @@ static void interlocked_decrement(void *arg)
ILInt32 result;
value = 1;
- result = ILInterlockedDecrement(&value);
+ result = ILInterlockedDecrementI4(&value);
if(result != 0)
{
- ILUnitFailed("ILInterlockedDecrement returned the wrong
result.\n"
+ ILUnitFailed("ILInterlockedDecrementI4 returned the wrong
result.\n"
"Expected: 0 bus was %i\n", result);
}
ILUnitAssert(value == 0);
@@ -1372,10 +1372,10 @@ static void interlocked_add(void *arg)
ILInt32 result;
value = 0;
- result = ILInterlockedAdd(&value, 5);
+ result = ILInterlockedAddI4(&value, 5);
if(result != 5)
{
- ILUnitFailed("ILInterlockedAdd returned the wrong result.\n"
+ ILUnitFailed("ILInterlockedAddI4 returned the wrong result.\n"
"Expected: 5 bus was %i\n", result);
}
ILUnitAssert(value == 5);
@@ -1387,10 +1387,10 @@ static void interlocked_sub(void *arg)
ILInt32 result;
value = 10;
- result = ILInterlockedSub(&value, 10);
+ result = ILInterlockedSubI4(&value, 10);
if(result != 0)
{
- ILUnitFailed("ILInterlockedSub returned the wrong result.\n"
+ ILUnitFailed("ILInterlockedSubI4 returned the wrong result.\n"
"Expected: 0 bus was %i\n", result);
}
ILUnitAssert(value == 0);
@@ -1407,7 +1407,7 @@ static void interlocked_and(void *arg)
volatile ILUInt32 value;
value = _TEST_START_VALUE;
- ILInterlockedAnd(&value, _TEST_AND_MASK);
+ ILInterlockedAndU4(&value, _TEST_AND_MASK);
ILUnitAssert(value == _TEST_AND_RESULT);
}
@@ -1416,7 +1416,7 @@ static void interlocked_or(void *arg)
volatile ILUInt32 value;
value = _TEST_START_VALUE;
- ILInterlockedOr(&value, _TEST_OR_MASK);
+ ILInterlockedOrU4(&value, _TEST_OR_MASK);
ILUnitAssert(value == _TEST_OR_RESULT);
}
@@ -1428,8 +1428,8 @@ static void _interlocked_thrash_incdec(void *arg)
ref = (ILInt32 *)arg;
for(counter = 0; counter < 1000000; ++counter)
{
- ILInterlockedIncrement_Acquire(ref);
- ILInterlockedDecrement_Release(ref);
+ ILInterlockedIncrementI4_Acquire(ref);
+ ILInterlockedDecrementI4_Release(ref);
}
}
@@ -1441,8 +1441,8 @@ static void _interlocked_thrash_addsub(void *arg)
ref = (ILInt32 *)arg;
for(counter = 0; counter < 1000000; ++counter)
{
- ILInterlockedAdd_Acquire(ref, 10);
- ILInterlockedSub_Release(ref, 10);
+ ILInterlockedAddI4_Acquire(ref, 10);
+ ILInterlockedSubI4_Release(ref, 10);
}
}
-----------------------------------------------------------------------
Summary of changes:
ChangeLog | 21 +
engine/cvm_call.c | 10 +-
engine/lib_defs.h | 2 +-
engine/lib_object.c | 2 +-
engine/lib_thread.c | 173 +--
engine/thread.c | 16 +-
support/interlocked.h | 106 +-
support/interlocked_any.h | 5300 +++++++++++++++++++++++++++++++++++++++------
support/interlocked_arm.h | 339 +--
support/interlocked_x86.h | 112 +-
support/monitor.c | 3 +-
tests/test_thread.c | 96 +-
12 files changed, 4931 insertions(+), 1249 deletions(-)
hooks/post-receive
--
DotGNU Portable.NET engine, compilers and tools (pnet)
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [dotgnu-pnet-commits] [SCM] DotGNU Portable.NET engine, compilers and tools (pnet) branch, master, updated. f325522c597e4e178037606c03c2b7c9a66ea637,
Klaus Treichel <=
- Prev by Date:
[dotgnu-pnet-commits] [SCM] DotGNU Portable.NET Just In Time compiler (libjit) branch, master, updated. b41fd4a38fce4d0f5c24e63609deff8d32d03f6f
- Next by Date:
[dotgnu-pnet-commits] [SCM] DotGNU Portable.NET engine, compilers and tools (pnet) branch, master, updated. 2e695f03776691ec000e65f21091d8e3fe68d62d
- Previous by thread:
[dotgnu-pnet-commits] [SCM] DotGNU Portable.NET Just In Time compiler (libjit) branch, master, updated. b41fd4a38fce4d0f5c24e63609deff8d32d03f6f
- Next by thread:
[dotgnu-pnet-commits] [SCM] DotGNU Portable.NET engine, compilers and tools (pnet) branch, master, updated. 2e695f03776691ec000e65f21091d8e3fe68d62d
- Index(es):