// 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;

				}