// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// e32test\system\t_atomic_common.cpp
// 
//

#ifdef __KERNEL_MODE__
#include <kernel/kernel.h>
#else
#define	__E32TEST_EXTENSION__

#include <e32test.h>

extern RTest test;

#define __INCLUDE_FUNC_NAMES__
#endif

#define __INCLUDE_ATOMIC_FUNCTIONS__
#define __INCLUDE_CONTROL_FUNCTIONS__
#define __INCLUDE_FUNCTION_ATTRIBUTES__

#include "t_atomic.h"

#define DEBUGPRINTVAR(x)	\
	{	\
	const TUint8* p = (const TUint8*)&(x);	\
	DEBUGPRINT("Line %d: " #x "=%02x %02x %02x %02x  %02x %02x %02x %02x", __LINE__, p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);	\
	}

extern "C" {

// Simulated versions of atomic functions without the atomicity
#define __LOAD(T)	return *(T*)a
#define	__STORE(T)	*(T*)a=v; return v
#define	__SWP(T)	T oldv=*(T*)a; *(T*)a=v; return oldv
#define __CAS(T)	if (*(T*)a==*q) {*(T*)a=v; return 1;} *q=*(T*)a; return 0
#define __ADD(T)	T oldv=*(T*)a; *(T*)a=(T)(oldv+v); return oldv
#define __AND(T)	T oldv=*(T*)a; *(T*)a=(T)(oldv&v); return oldv
#define __IOR(T)	T oldv=*(T*)a; *(T*)a=(T)(oldv|v); return oldv
#define __XOR(T)	T oldv=*(T*)a; *(T*)a=(T)(oldv^v); return oldv
#define __AXO(T)	T oldv=*(T*)a; *(T*)a=(T)((oldv&u)^v); return oldv
#define __TA(T)		T oldv=*(T*)a; *(T*)a=(T)(oldv+((oldv>=t)?u:v)); return oldv

TUint8	__nonatomic_load8(const volatile TAny* a)
	{
	__LOAD(TUint8);
	}

TUint8	__nonatomic_store8(volatile TAny* a, TUint8 v)
	{
	__STORE(TUint8);
	}

TUint8	__nonatomic_swp8(volatile TAny* a, TUint8 v)
	{
	__SWP(TUint8);
	}

TBool	__nonatomic_cas8(volatile TAny* a, TUint8* q, TUint8 v)
	{
	__CAS(TUint8);
	}

TUint8	__nonatomic_add8(volatile TAny* a, TUint8 v)
	{
	__ADD(TUint8);
	}

TUint8	__nonatomic_and8(volatile TAny* a, TUint8 v)
	{
	__AND(TUint8);
	}

TUint8	__nonatomic_ior8(volatile TAny* a, TUint8 v)
	{
	__IOR(TUint8);
	}

TUint8	__nonatomic_xor8(volatile TAny* a, TUint8 v)
	{
	__XOR(TUint8);
	}

TUint8	__nonatomic_axo8(volatile TAny* a, TUint8 u, TUint8 v)
	{
	__AXO(TUint8);
	}

TUint8	__nonatomic_tau8(volatile TAny* a, TUint8 t, TUint8 u, TUint8 v)
	{
	__TA(TUint8);
	}

TInt8	__nonatomic_tas8(volatile TAny* a, TInt8 t, TInt8 u, TInt8 v)
	{
	__TA(TInt8);
	}


TUint16	__nonatomic_load16(const volatile TAny* a)
	{
	__LOAD(TUint16);
	}

TUint16	__nonatomic_store16(volatile TAny* a, TUint16 v)
	{
	__STORE(TUint16);
	}

TUint16	__nonatomic_swp16(volatile TAny* a, TUint16 v)
	{
	__SWP(TUint16);
	}

TBool	__nonatomic_cas16(volatile TAny* a, TUint16* q, TUint16 v)
	{
	__CAS(TUint16);
	}

TUint16	__nonatomic_add16(volatile TAny* a, TUint16 v)
	{
	__ADD(TUint16);
	}

TUint16	__nonatomic_and16(volatile TAny* a, TUint16 v)
	{
	__AND(TUint16);
	}

TUint16	__nonatomic_ior16(volatile TAny* a, TUint16 v)
	{
	__IOR(TUint16);
	}

TUint16	__nonatomic_xor16(volatile TAny* a, TUint16 v)
	{
	__XOR(TUint16);
	}

TUint16	__nonatomic_axo16(volatile TAny* a, TUint16 u, TUint16 v)
	{
	__AXO(TUint16);
	}

TUint16	__nonatomic_tau16(volatile TAny* a, TUint16 t, TUint16 u, TUint16 v)
	{
	__TA(TUint16);
	}

TInt16	__nonatomic_tas16(volatile TAny* a, TInt16 t, TInt16 u, TInt16 v)
	{
	__TA(TInt16);
	}


TUint32	__nonatomic_load32(const volatile TAny* a)
	{
	__LOAD(TUint32);
	}

TUint32	__nonatomic_store32(volatile TAny* a, TUint32 v)
	{
	__STORE(TUint32);
	}

TUint32	__nonatomic_swp32(volatile TAny* a, TUint32 v)
	{
	__SWP(TUint32);
	}

TBool	__nonatomic_cas32(volatile TAny* a, TUint32* q, TUint32 v)
	{
	__CAS(TUint32);
	}

TUint32	__nonatomic_add32(volatile TAny* a, TUint32 v)
	{
	__ADD(TUint32);
	}

TUint32	__nonatomic_and32(volatile TAny* a, TUint32 v)
	{
	__AND(TUint32);
	}

TUint32	__nonatomic_ior32(volatile TAny* a, TUint32 v)
	{
	__IOR(TUint32);
	}

TUint32	__nonatomic_xor32(volatile TAny* a, TUint32 v)
	{
	__XOR(TUint32);
	}

TUint32	__nonatomic_axo32(volatile TAny* a, TUint32 u, TUint32 v)
	{
	__AXO(TUint32);
	}

TUint32	__nonatomic_tau32(volatile TAny* a, TUint32 t, TUint32 u, TUint32 v)
	{
	__TA(TUint32);
	}

TInt32	__nonatomic_tas32(volatile TAny* a, TInt32 t, TInt32 u, TInt32 v)
	{
	__TA(TInt32);
	}


TUint64	__nonatomic_load64(const volatile TAny* a)
	{
	__LOAD(TUint64);
	}

TUint64	__nonatomic_store64(volatile TAny* a, TUint64 v)
	{
	__STORE(TUint64);
	}

TUint64	__nonatomic_swp64(volatile TAny* a, TUint64 v)
	{
	__SWP(TUint64);
	}

TBool	__nonatomic_cas64(volatile TAny* a, TUint64* q, TUint64 v)
	{
	__CAS(TUint64);
	}

TUint64	__nonatomic_add64(volatile TAny* a, TUint64 v)
	{
	__ADD(TUint64);
	}

TUint64	__nonatomic_and64(volatile TAny* a, TUint64 v)
	{
	__AND(TUint64);
	}

TUint64	__nonatomic_ior64(volatile TAny* a, TUint64 v)
	{
	__IOR(TUint64);
	}

TUint64	__nonatomic_xor64(volatile TAny* a, TUint64 v)
	{
	__XOR(TUint64);
	}

TUint64	__nonatomic_axo64(volatile TAny* a, TUint64 u, TUint64 v)
	{
	__AXO(TUint64);
	}

TUint64	__nonatomic_tau64(volatile TAny* a, TUint64 t, TUint64 u, TUint64 v)
	{
	__TA(TUint64);
	}

TInt64	__nonatomic_tas64(volatile TAny* a, TInt64 t, TInt64 u, TInt64 v)
	{
	__TA(TInt64);
	}

} // extern "C"


#define	DEBUGPRINTxyrc()	\
		DEBUGPRINTVAR(x);	\
		DEBUGPRINTVAR(y);	\
		DEBUGPRINTVAR(r);	\
		DEBUGPRINTVAR(c)

template<class T> TInt DoLoadTest(TInt aIndex, TAny* aPtr, T aInitialValue)
	{
#ifdef __EXTRA_DEBUG__
	DEBUGPRINT("DoLoadTest %d %08x", aIndex, aPtr);
#endif
	typename TLoadFn<T>::F atomic = (typename TLoadFn<T>::F)AtomicFuncPtr[aIndex];
	typename TLoadFn<T>::F control = (typename TLoadFn<T>::F)ControlFuncPtr[aIndex];
	T& x = *(T*)aPtr;
	x = aInitialValue;
	T y = aInitialValue;
	T r = atomic(&x);
	T c = control(&y);
	if (r!=c || x!=y)
		{
		DEBUGPRINTxyrc();
		return __LINE__;
		}
	return 0;
	}

template<class T> TInt DoRmw1Test(TInt aIndex, TAny* aPtr, T aInitialValue, T a1)
	{
#ifdef __EXTRA_DEBUG__
	DEBUGPRINT("DoRmw1Test %d %08x", aIndex, aPtr);
#endif
	typename TRmw1Fn<T>::F atomic = (typename TRmw1Fn<T>::F)AtomicFuncPtr[aIndex];
	typename TRmw1Fn<T>::F control = (typename TRmw1Fn<T>::F)ControlFuncPtr[aIndex];
	T& x = *(T*)aPtr;
	x = aInitialValue;
	T y = aInitialValue;
	T r = atomic(&x,a1);
	T c = control(&y,a1);
	if (r!=c || x!=y)
		{
		DEBUGPRINTxyrc();
		return __LINE__;
		}
	return 0;
	}

template<class T> TInt DoRmw2Test(TInt aIndex, TAny* aPtr, T aInitialValue, T a1, T a2)
	{
#ifdef __EXTRA_DEBUG__
	DEBUGPRINT("DoRmw2Test %d %08x", aIndex, aPtr);
#endif
	typename TRmw2Fn<T>::F atomic = (typename TRmw2Fn<T>::F)AtomicFuncPtr[aIndex];
	typename TRmw2Fn<T>::F control = (typename TRmw2Fn<T>::F)ControlFuncPtr[aIndex];
	T& x = *(T*)aPtr;
	x = aInitialValue;
	T y = aInitialValue;
	T r = atomic(&x,a1,a2);
	T c = control(&y,a1,a2);
	if (r!=c || x!=y)
		{
		DEBUGPRINTxyrc();
		return __LINE__;
		}
	return 0;
	}

template<class T> TInt DoRmw3Test(TInt aIndex, TAny* aPtr, T aInitialValue, T a1, T a2, T a3)
	{
#ifdef __EXTRA_DEBUG__
	DEBUGPRINT("DoRmw3Test %d %08x", aIndex, aPtr);
#endif
	typename TRmw3Fn<T>::F atomic = (typename TRmw3Fn<T>::F)AtomicFuncPtr[aIndex];
	typename TRmw3Fn<T>::F control = (typename TRmw3Fn<T>::F)ControlFuncPtr[aIndex];
	T& x = *(T*)aPtr;
	x = aInitialValue;
	T y = aInitialValue;
	T r = atomic(&x,a1,a2,a3);
	T c = control(&y,a1,a2,a3);
	if (r!=c || x!=y)
		{
		DEBUGPRINTxyrc();
		return __LINE__;
		}
	return 0;
	}

template<class T> TInt DoCasTest(TInt aIndex, TAny* aPtr, T aInitialValue, T aExpectedValue, T aFinalValue)
	{
#ifdef __EXTRA_DEBUG__
	DEBUGPRINT("DoCasTest %d %08x", aIndex, aPtr);
#endif
	typename TCasFn<T>::F atomic = (typename TCasFn<T>::F)AtomicFuncPtr[aIndex];
	typename TCasFn<T>::F control = (typename TCasFn<T>::F)ControlFuncPtr[aIndex];
	T& x = *(T*)aPtr;
	x = aInitialValue;
	T ex = aExpectedValue;
	T y = aInitialValue;
	T ey = aExpectedValue;
	TBool r = atomic(&x,&ex,aFinalValue);
	TBool c = control(&y,&ey,aFinalValue);
	TInt line = 0;
	if (r && !c)
		line = __LINE__;
	else if (!r && c)
		line = __LINE__;
	else if (x!=y)
		line = __LINE__;
	else if (ex!=ey)
		line = __LINE__;
	else if (r && x!=aFinalValue)
		line = __LINE__;
	else if (!r && ex!=aInitialValue)
		line = __LINE__;
	if (line)
		{
		DEBUGPRINT("r=%d",r);
		DEBUGPRINTVAR(x);
		DEBUGPRINTVAR(ex);
		DEBUGPRINT("c=%d",c);
		DEBUGPRINTVAR(y);
		DEBUGPRINTVAR(ey);
		}
	return line;
	}



TEnclosed::TEnclosed(TInt aSize)
	{
	iOffset = -1;
	iSize = aSize;
	iData = (TUint64*)((T_UintPtr(i_Data) + 7) &~ 7);	// align up to next 8 byte boundary
	iBackup = iData + 8;
	}

TAny* TEnclosed::Ptr()
	{
	return ((TUint8*)iData + iOffset);
	}

TInt TEnclosed::Next()
	{
	const TInt KLimit[8] = {8, 16, 0, 32, 0, 0, 0, 32};
	if (iOffset<0)
		iOffset = 0;
	else
		{
		TInt r = Verify();
		if (r!=0)
			return r;
		iOffset += iSize;
		}
	if (iOffset >= KLimit[iSize-1])
		return KErrEof;
	Init();
	return KErrNone;
	}

void TEnclosed::Init()
	{
	TUint32 x = iOffset+1;
	x |= (x<<8);
	x |= (x<<16);
	TUint32* d = (TUint32*)iData;
	TUint32* b = (TUint32*)iBackup;
	TInt i;
	for (i=0; i<16; ++i)
		{
		*d++ = x;
		*b++ = x;
		x = 69069*x + 41;
		}
	}

TInt TEnclosed::Verify()
	{
	TUint8* d = (TUint8*)iData;
	const TUint8* b = (const TUint8*)iBackup;
	TInt i;
	for (i=0; i<iSize; ++i)
		d[iOffset+i] = b[iOffset+i];
	if (memcompare(b,64,d,64))
		{
		DEBUGPRINT("FAIL! iOffset=%02x, sizeof(T)=%1d", iOffset, iSize);
		for (i=0; i<64; ++i)
			{
			if (d[i]!=b[i])
				{
				DEBUGPRINT("d[%02x]=%02x b[%02x]=%02x", i, d[i], i, b[i]);
				}
			}
		return __LINE__;
		}
	return 0;
	}


TInt TDGBase::Execute()
	{
	PFV af0 = AtomicFuncPtr[iIndex];
	PFV cf0 = ControlFuncPtr[iIndex];
	if (!af0 || !cf0)
		return __LINE__;
	TUint attr = FuncAttr[iIndex];
	TInt type = ATTR_TO_TYPE(attr);
	TInt size = ATTR_TO_SIZE(attr);
	TInt func = ATTR_TO_FUNC(attr);
	if (type==EFuncTypeInvalid)
		return __LINE__;
#ifdef __EXTRA_DEBUG__
	TInt ord = ATTR_TO_ORD(attr);
	DEBUGPRINT("A=%08x T=%d O=%d S=%d F=%d", attr, type, ord, size, func);
#endif
	TEnclosed enc(size);
	TInt res = 0;
	while ( (res = enc.Next()) == KErrNone )
		{
#ifdef __EXTRA_DEBUG__
		DEBUGPRINT("Offset %02x", enc.Offset());
#endif
		TAny* ptr = enc.Ptr();
		switch (type)
			{
			case EFuncTypeLoad:
				{
				switch (size)
					{
					case 1:	res = DoLoadTest<TUint8>(iIndex, ptr, (TUint8)i0); break;
					case 2:	res = DoLoadTest<TUint16>(iIndex, ptr, (TUint16)i0); break;
					case 4:	res = DoLoadTest<TUint32>(iIndex, ptr, (TUint32)i0); break;
					case 8:	res = DoLoadTest<TUint64>(iIndex, ptr, i0); break;
					default: res = __LINE__; break;
					}
				break;
				}
			case EFuncTypeRmw1:
				{
				switch (size)
					{
					case 1:	res = DoRmw1Test<TUint8>(iIndex, ptr, (TUint8)i0, (TUint8)i1); break;
					case 2:	res = DoRmw1Test<TUint16>(iIndex, ptr, (TUint16)i0, (TUint16)i1); break;
					case 4:	res = DoRmw1Test<TUint32>(iIndex, ptr, (TUint32)i0, (TUint32)i1); break;
					case 8:	res = DoRmw1Test<TUint64>(iIndex, ptr, i0, i1); break;
					default: res = __LINE__; break;
					}
				break;
				}
			case EFuncTypeRmw2:
				{
				switch (size)
					{
					case 1:	res = DoRmw2Test<TUint8>(iIndex, ptr, (TUint8)i0, (TUint8)i1, (TUint8)i2); break;
					case 2:	res = DoRmw2Test<TUint16>(iIndex, ptr, (TUint16)i0, (TUint16)i1, (TUint16)i2); break;
					case 4:	res = DoRmw2Test<TUint32>(iIndex, ptr, (TUint32)i0, (TUint32)i1, (TUint32)i2); break;
					case 8:	res = DoRmw2Test<TUint64>(iIndex, ptr, i0, i1, i2); break;
					default: res = __LINE__; break;
					}
				break;
				}
			case EFuncTypeRmw3:
				{
				if (func==EAtomicFuncTAU)
					{
					switch (size)
						{
						case 1:	res = DoRmw3Test<TUint8>(iIndex, ptr, (TUint8)i0, (TUint8)i1, (TUint8)i2, (TUint8)i3); break;
						case 2:	res = DoRmw3Test<TUint16>(iIndex, ptr, (TUint16)i0, (TUint16)i1, (TUint16)i2, (TUint16)i3); break;
						case 4:	res = DoRmw3Test<TUint32>(iIndex, ptr, (TUint32)i0, (TUint32)i1, (TUint32)i2, (TUint32)i3); break;
						case 8:	res = DoRmw3Test<TUint64>(iIndex, ptr, i0, i1, i2, i3); break;
						default: res = __LINE__; break;
						}
					}
				else if (func==EAtomicFuncTAS)
					{
					switch (size)
						{
						case 1:	res = DoRmw3Test<TInt8>(iIndex, ptr, (TInt8)i0, (TInt8)i1, (TInt8)i2, (TInt8)i3); break;
						case 2:	res = DoRmw3Test<TInt16>(iIndex, ptr, (TInt16)i0, (TInt16)i1, (TInt16)i2, (TInt16)i3); break;
						case 4:	res = DoRmw3Test<TInt32>(iIndex, ptr, (TInt32)i0, (TInt32)i1, (TInt32)i2, (TInt32)i3); break;
						case 8:	res = DoRmw3Test<TInt64>(iIndex, ptr, i0, i1, i2, i3); break;
						default: res = __LINE__; break;
						}
					}
				else
					res = __LINE__;
				break;
				}
			case EFuncTypeCas:
				{
				switch (size)
					{
					case 1:	res = DoCasTest<TUint8>(iIndex, ptr, (TUint8)i0, (TUint8)i1, (TUint8)i2); break;
					case 2:	res = DoCasTest<TUint16>(iIndex, ptr, (TUint16)i0, (TUint16)i1, (TUint16)i2); break;
					case 4:	res = DoCasTest<TUint32>(iIndex, ptr, (TUint32)i0, (TUint32)i1, (TUint32)i2); break;
					case 8:	res = DoCasTest<TUint64>(iIndex, ptr, i0, i1, i2); break;
					default: res = __LINE__; break;
					}
				break;
				}
			default:
				res = __LINE__;
				break;
			}
		if (res)
			return res;
		}
	if (res == KErrEof)
		res = 0;
	return res;
	}

#ifndef __KERNEL_MODE__
void TDGBase::Dump(const char* aTitle)
	{
	TPtrC8 fname8((const TText8*)FuncName[iIndex]);
	TBuf<64> fname;
	fname.Copy(fname8);
	DEBUGPRINT(aTitle);
	DEBUGPRINT("iIndex=%d (%S)", iIndex, &fname);
	DEBUGPRINT("i0 = %08x %08x", I64HIGH(i0), I64LOW(i0));
	DEBUGPRINT("i1 = %08x %08x", I64HIGH(i1), I64LOW(i1));
	DEBUGPRINT("i2 = %08x %08x", I64HIGH(i2), I64LOW(i2));
	DEBUGPRINT("i3 = %08x %08x", I64HIGH(i3), I64LOW(i3));
	}
#endif

template<class T> TInt DoSwap(TAny* aPtr, TPerThread* aT, TAtomicAction& aA, T*)
	{
	typename TRmw1Fn<T>::F atomic = (typename TRmw1Fn<T>::F)AtomicFuncPtr[aA.iIndex];
	T newv = (T)aA.i0;
	T orig = atomic(aPtr, newv);
	T xr = (T)(newv ^ orig);
	aT->iXor ^= xr;
	T diff = (T)(newv - orig);
	aT->iDiff += diff;
	return 0;
	}

template<class T> TInt DoAdd(TAny* aPtr, TPerThread* aT, TAtomicAction& aA, T*)
	{
	typename TRmw1Fn<T>::F atomic = (typename TRmw1Fn<T>::F)AtomicFuncPtr[aA.iIndex];
	T arg = (T)aA.i0;
	T orig = atomic(aPtr, arg);
	T xr = (T)((arg+orig) ^ orig);
	aT->iXor ^= xr;
	aT->iDiff += arg;
	return 0;
	}

template<class T> TInt DoXor(TAny* aPtr, TPerThread* aT, TAtomicAction& aA, T*)
	{
	typename TRmw1Fn<T>::F atomic = (typename TRmw1Fn<T>::F)AtomicFuncPtr[aA.iIndex];
	T arg = (T)aA.i0;
	T orig = atomic(aPtr, arg);
	T diff = (T)((arg^orig) - orig);
	aT->iDiff += diff;
	aT->iXor ^= arg;
	return 0;
	}

template<class T> TInt DoAndOr(TAny* aPtr, TPerThread* aT, TAtomicAction& aA, T*)
	{
	typename TRmw1Fn<T>::F atomic_and = (typename TRmw1Fn<T>::F)AtomicFuncPtr[aA.iIndex];
	typename TRmw1Fn<T>::F atomic_or = (typename TRmw1Fn<T>::F)AtomicFuncPtr[aA.iIndex+4];
	T aarg = (T)aA.i0;
	T oarg = (T)aA.i1;
	T aorig = atomic_and(aPtr, aarg);
	T oorig = atomic_or(aPtr, oarg);
	T adiff = (T)((aorig & aarg) - aorig);
	T odiff = (T)((oorig | oarg) - oorig);
	aT->iDiff += adiff + odiff;
	T axor = (T)((aorig & aarg) ^ aorig);
	T oxor = (T)((oorig | oarg) ^ oorig);
	aT->iXor ^= axor ^ oxor;
	return 0;
	}

template<class T> TInt DoAxo(TAny* aPtr, TPerThread* aT, TAtomicAction& aA, T*)
	{
	typename TRmw2Fn<T>::F atomic = (typename TRmw2Fn<T>::F)AtomicFuncPtr[aA.iIndex];
	T aarg = (T)aA.i0;
	T xarg = (T)aA.i1;
	T orig = atomic(aPtr, aarg, xarg);
	T newv = (T)((orig & aarg) ^ xarg);
	aT->iDiff += (newv - orig);
	aT->iXor ^= (newv ^ orig);
	return 0;
	}

template<class T> TInt DoThAdd(TAny* aPtr, TPerThread* aT, TAtomicAction& aA, T*)
	{
	typename TRmw3Fn<T>::F atomic = (typename TRmw3Fn<T>::F)AtomicFuncPtr[aA.iIndex];
	T thr = (T)aA.i0;
	T arg1 = (T)aA.i1;
	T arg2 = (T)aA.i2;
	T orig = atomic(aPtr, thr, arg1, arg2);
	T newv = (T)((orig >= thr) ? (orig + arg1) : (orig + arg2));
	aT->iDiff += (orig >= thr) ? arg1 : arg2;
	aT->iXor ^= (newv ^ orig);
	return 0;
	}

template<class T> TInt DoCas(TAny* aPtr, TPerThread* aT, TAtomicAction& aA, T*)
	{
	typename TCasFn<T>::F atomic = (typename TCasFn<T>::F)AtomicFuncPtr[aA.iIndex];
	T orig = *(const volatile T*)aPtr;
	T newv;
	TBool done = FALSE;
	TUint32 fails = 0xffffffffu;
	do	{
		++fails;
		newv = Transform<T>::F(orig);
		done = atomic(aPtr, &orig, newv);
		} while(!done);
	aT->iFailCount += fails;
	++aT->iDiff;
	aT->iXor ^= (newv ^ orig);
	return 0;
	}

volatile TUint Dummy;
extern "C" TInt DoAtomicAction(TAny* aPtr, TPerThread* aT, TAtomicAction& aA)
	{
	TUint x = TUint(aT)*0x9E3779B9u;
	x = (x>>8)&15;
	while(x--)
		++Dummy;
	TInt r = KErrNotSupported;
	TUint attr = FuncAttr[aA.iIndex];
	TUint func = ATTR_TO_FUNC(attr);
	TUint size = ATTR_TO_SIZE(attr);
	switch (size)
		{
		case 1:
			{
			TUint8 xx;
			TUint8* dummy = &xx;
			TInt8 yy;
			TInt8* sdummy = &yy;
			switch (func)
				{
				case EAtomicFuncSWP:	r=DoSwap<TUint8>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncADD:	r=DoAdd<TUint8>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncAND:	r=DoAndOr<TUint8>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncXOR:	r=DoXor<TUint8>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncAXO:	r=DoAxo<TUint8>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncTAU:	r=DoThAdd<TUint8>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncTAS:	r=DoThAdd<TInt8>(aPtr, aT, aA, sdummy); break;
				case EAtomicFuncCAS:	r=DoCas<TUint8>(aPtr, aT, aA, dummy); break;
				default: break;
				}
			break;
			}
		case 2:
			{
			TUint16 xx;
			TUint16* dummy = &xx;
			TInt16 yy;
			TInt16* sdummy = &yy;
			switch (func)
				{
				case EAtomicFuncSWP:	r=DoSwap<TUint16>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncADD:	r=DoAdd<TUint16>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncAND:	r=DoAndOr<TUint16>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncXOR:	r=DoXor<TUint16>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncAXO:	r=DoAxo<TUint16>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncTAU:	r=DoThAdd<TUint16>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncTAS:	r=DoThAdd<TInt16>(aPtr, aT, aA, sdummy); break;
				case EAtomicFuncCAS:	r=DoCas<TUint16>(aPtr, aT, aA, dummy); break;
				default: break;
				}
			break;
			}
		case 4:
			{
			TUint32 xx;
			TUint32* dummy = &xx;
			TInt32 yy;
			TInt32* sdummy = &yy;
			switch (func)
				{
				case EAtomicFuncSWP:	r=DoSwap<TUint32>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncADD:	r=DoAdd<TUint32>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncAND:	r=DoAndOr<TUint32>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncXOR:	r=DoXor<TUint32>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncAXO:	r=DoAxo<TUint32>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncTAU:	r=DoThAdd<TUint32>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncTAS:	r=DoThAdd<TInt32>(aPtr, aT, aA, sdummy); break;
				case EAtomicFuncCAS:	r=DoCas<TUint32>(aPtr, aT, aA, dummy); break;
				default: break;
				}
			break;
			}
		case 8:
			{
			TUint64A xx;
			TUint64* dummy = &xx;
			TInt64A yy;
			TInt64* sdummy = &yy;
			switch (func)
				{
				case EAtomicFuncSWP:	r=DoSwap<TUint64>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncADD:	r=DoAdd<TUint64>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncAND:	r=DoAndOr<TUint64>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncXOR:	r=DoXor<TUint64>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncAXO:	r=DoAxo<TUint64>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncTAU:	r=DoThAdd<TUint64>(aPtr, aT, aA, dummy); break;
				case EAtomicFuncTAS:	r=DoThAdd<TInt64>(aPtr, aT, aA, sdummy); break;
				case EAtomicFuncCAS:	r=DoCas<TUint64>(aPtr, aT, aA, dummy); break;
				default: break;
				}
			break;
			}
		default:
			break;
		}
	++aT->iCount;
	return r;
	}