[mirror_ubuntu-zesty-kernel.git] / arch / arm / nwfpe / fpa11_cpdt.c

/*
    NetWinder Floating Point Emulator
    (c) Rebel.com, 1998-1999
    (c) Philip Blundell, 1998, 2001

    Direct questions, comments to Scott Bambrough <scottb@netwinder.org>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "fpa11.h"
#include "softfloat.h"
#include "fpopcode.h"
#include "fpmodule.h"
#include "fpmodule.inl"

#include <linux/uaccess.h>

static inline void loadSingle(const unsigned int Fn, const unsigned int __user *pMem)
{
	FPA11 *fpa11 = GET_FPA11();
	fpa11->fType[Fn] = typeSingle;
	get_user(fpa11->fpreg[Fn].fSingle, pMem);
}

static inline void loadDouble(const unsigned int Fn, const unsigned int __user *pMem)
{
	FPA11 *fpa11 = GET_FPA11();
	unsigned int *p;
	p = (unsigned int *) &fpa11->fpreg[Fn].fDouble;
	fpa11->fType[Fn] = typeDouble;
#ifdef __ARMEB__
	get_user(p[0], &pMem[0]);	/* sign & exponent */
	get_user(p[1], &pMem[1]);
#else
	get_user(p[0], &pMem[1]);
	get_user(p[1], &pMem[0]);	/* sign & exponent */
#endif
}

#ifdef CONFIG_FPE_NWFPE_XP
static inline void loadExtended(const unsigned int Fn, const unsigned int __user *pMem)
{
	FPA11 *fpa11 = GET_FPA11();
	unsigned int *p;
	p = (unsigned int *) &fpa11->fpreg[Fn].fExtended;
	fpa11->fType[Fn] = typeExtended;
	get_user(p[0], &pMem[0]);	/* sign & exponent */
#ifdef __ARMEB__
	get_user(p[1], &pMem[1]);	/* ms bits */
	get_user(p[2], &pMem[2]);	/* ls bits */
#else
	get_user(p[1], &pMem[2]);	/* ls bits */
	get_user(p[2], &pMem[1]);	/* ms bits */
#endif
}
#endif

static inline void loadMultiple(const unsigned int Fn, const unsigned int __user *pMem)
{
	FPA11 *fpa11 = GET_FPA11();
	register unsigned int *p;
	unsigned long x;

	p = (unsigned int *) &(fpa11->fpreg[Fn]);
	get_user(x, &pMem[0]);
	fpa11->fType[Fn] = (x >> 14) & 0x00000003;

	switch (fpa11->fType[Fn]) {
	case typeSingle:
	case typeDouble:
		{
			get_user(p[0], &pMem[2]);	/* Single */
			get_user(p[1], &pMem[1]);	/* double msw */
			p[2] = 0;			/* empty */
		}
		break;

#ifdef CONFIG_FPE_NWFPE_XP
	case typeExtended:
		{
			get_user(p[1], &pMem[2]);
			get_user(p[2], &pMem[1]);	/* msw */
			p[0] = (x & 0x80003fff);
		}
		break;
#endif
	}
}

static inline void storeSingle(struct roundingData *roundData, const unsigned int Fn, unsigned int __user *pMem)
{
	FPA11 *fpa11 = GET_FPA11();
	union {
		float32 f;
		unsigned int i[1];
	} val;

	switch (fpa11->fType[Fn]) {
	case typeDouble:
		val.f = float64_to_float32(roundData, fpa11->fpreg[Fn].fDouble);
		break;

#ifdef CONFIG_FPE_NWFPE_XP
	case typeExtended:
		val.f = floatx80_to_float32(roundData, fpa11->fpreg[Fn].fExtended);
		break;
#endif

	default:
		val.f = fpa11->fpreg[Fn].fSingle;
	}

	put_user(val.i[0], pMem);
}

static inline void storeDouble(struct roundingData *roundData, const unsigned int Fn, unsigned int __user *pMem)
{
	FPA11 *fpa11 = GET_FPA11();
	union {
		float64 f;
		unsigned int i[2];
	} val;

	switch (fpa11->fType[Fn]) {
	case typeSingle:
		val.f = float32_to_float64(fpa11->fpreg[Fn].fSingle);
		break;

#ifdef CONFIG_FPE_NWFPE_XP
	case typeExtended:
		val.f = floatx80_to_float64(roundData, fpa11->fpreg[Fn].fExtended);
		break;
#endif

	default:
		val.f = fpa11->fpreg[Fn].fDouble;
	}

#ifdef __ARMEB__
	put_user(val.i[0], &pMem[0]);	/* msw */
	put_user(val.i[1], &pMem[1]);	/* lsw */
#else
	put_user(val.i[1], &pMem[0]);	/* msw */
	put_user(val.i[0], &pMem[1]);	/* lsw */
#endif
}

#ifdef CONFIG_FPE_NWFPE_XP
static inline void storeExtended(const unsigned int Fn, unsigned int __user *pMem)
{
	FPA11 *fpa11 = GET_FPA11();
	union {
		floatx80 f;
		unsigned int i[3];
	} val;

	switch (fpa11->fType[Fn]) {
	case typeSingle:
		val.f = float32_to_floatx80(fpa11->fpreg[Fn].fSingle);
		break;

	case typeDouble:
		val.f = float64_to_floatx80(fpa11->fpreg[Fn].fDouble);
		break;

	default:
		val.f = fpa11->fpreg[Fn].fExtended;
	}

	put_user(val.i[0], &pMem[0]);	/* sign & exp */
#ifdef __ARMEB__
	put_user(val.i[1], &pMem[1]);	/* msw */
	put_user(val.i[2], &pMem[2]);
#else
	put_user(val.i[1], &pMem[2]);
	put_user(val.i[2], &pMem[1]);	/* msw */
#endif
}
#endif

static inline void storeMultiple(const unsigned int Fn, unsigned int __user *pMem)
{
	FPA11 *fpa11 = GET_FPA11();
	register unsigned int nType, *p;

	p = (unsigned int *) &(fpa11->fpreg[Fn]);
	nType = fpa11->fType[Fn];

	switch (nType) {
	case typeSingle:
	case typeDouble:
		{
			put_user(p[0], &pMem[2]);	/* single */
			put_user(p[1], &pMem[1]);	/* double msw */
			put_user(nType << 14, &pMem[0]);
		}
		break;

#ifdef CONFIG_FPE_NWFPE_XP
	case typeExtended:
		{
			put_user(p[2], &pMem[1]);	/* msw */
			put_user(p[1], &pMem[2]);
			put_user((p[0] & 0x80003fff) | (nType << 14), &pMem[0]);
		}
		break;
#endif
	}
}

unsigned int PerformLDF(const unsigned int opcode)
{
	unsigned int __user *pBase, *pAddress, *pFinal;
	unsigned int nRc = 1, write_back = WRITE_BACK(opcode);

	pBase = (unsigned int __user *) readRegister(getRn(opcode));
	if (REG_PC == getRn(opcode)) {
		pBase += 2;
		write_back = 0;
	}

	pFinal = pBase;
	if (BIT_UP_SET(opcode))
		pFinal += getOffset(opcode);
	else
		pFinal -= getOffset(opcode);

	if (PREINDEXED(opcode))
		pAddress = pFinal;
	else
		pAddress = pBase;

	switch (opcode & MASK_TRANSFER_LENGTH) {
	case TRANSFER_SINGLE:
		loadSingle(getFd(opcode), pAddress);
		break;
	case TRANSFER_DOUBLE:
		loadDouble(getFd(opcode), pAddress);
		break;
#ifdef CONFIG_FPE_NWFPE_XP
	case TRANSFER_EXTENDED:
		loadExtended(getFd(opcode), pAddress);
		break;
#endif
	default:
		nRc = 0;
	}

	if (write_back)
		writeRegister(getRn(opcode), (unsigned long) pFinal);
	return nRc;
}

unsigned int PerformSTF(const unsigned int opcode)
{
	unsigned int __user *pBase, *pAddress, *pFinal;
	unsigned int nRc = 1, write_back = WRITE_BACK(opcode);
	struct roundingData roundData;

	roundData.mode = SetRoundingMode(opcode);
	roundData.precision = SetRoundingPrecision(opcode);
	roundData.exception = 0;

	pBase = (unsigned int __user *) readRegister(getRn(opcode));
	if (REG_PC == getRn(opcode)) {
		pBase += 2;
		write_back = 0;
	}

	pFinal = pBase;
	if (BIT_UP_SET(opcode))
		pFinal += getOffset(opcode);
	else
		pFinal -= getOffset(opcode);

	if (PREINDEXED(opcode))
		pAddress = pFinal;
	else
		pAddress = pBase;

	switch (opcode & MASK_TRANSFER_LENGTH) {
	case TRANSFER_SINGLE:
		storeSingle(&roundData, getFd(opcode), pAddress);
		break;
	case TRANSFER_DOUBLE:
		storeDouble(&roundData, getFd(opcode), pAddress);
		break;
#ifdef CONFIG_FPE_NWFPE_XP
	case TRANSFER_EXTENDED:
		storeExtended(getFd(opcode), pAddress);
		break;
#endif
	default:
		nRc = 0;
	}

	if (roundData.exception)
		float_raise(roundData.exception);

	if (write_back)
		writeRegister(getRn(opcode), (unsigned long) pFinal);
	return nRc;
}

unsigned int PerformLFM(const unsigned int opcode)
{
	unsigned int __user *pBase, *pAddress, *pFinal;
	unsigned int i, Fd, write_back = WRITE_BACK(opcode);

	pBase = (unsigned int __user *) readRegister(getRn(opcode));
	if (REG_PC == getRn(opcode)) {
		pBase += 2;
		write_back = 0;
	}

	pFinal = pBase;
	if (BIT_UP_SET(opcode))
		pFinal += getOffset(opcode);
	else
		pFinal -= getOffset(opcode);

	if (PREINDEXED(opcode))
		pAddress = pFinal;
	else
		pAddress = pBase;

	Fd = getFd(opcode);
	for (i = getRegisterCount(opcode); i > 0; i--) {
		loadMultiple(Fd, pAddress);
		pAddress += 3;
		Fd++;
		if (Fd == 8)
			Fd = 0;
	}

	if (write_back)
		writeRegister(getRn(opcode), (unsigned long) pFinal);
	return 1;
}

unsigned int PerformSFM(const unsigned int opcode)
{
	unsigned int __user *pBase, *pAddress, *pFinal;
	unsigned int i, Fd, write_back = WRITE_BACK(opcode);

	pBase = (unsigned int __user *) readRegister(getRn(opcode));
	if (REG_PC == getRn(opcode)) {
		pBase += 2;
		write_back = 0;
	}

	pFinal = pBase;
	if (BIT_UP_SET(opcode))
		pFinal += getOffset(opcode);
	else
		pFinal -= getOffset(opcode);

	if (PREINDEXED(opcode))
		pAddress = pFinal;
	else
		pAddress = pBase;

	Fd = getFd(opcode);
	for (i = getRegisterCount(opcode); i > 0; i--) {
		storeMultiple(Fd, pAddress);
		pAddress += 3;
		Fd++;
		if (Fd == 8)
			Fd = 0;
	}

	if (write_back)
		writeRegister(getRn(opcode), (unsigned long) pFinal);
	return 1;
}

unsigned int EmulateCPDT(const unsigned int opcode)
{
	unsigned int nRc = 0;

	if (LDF_OP(opcode)) {
		nRc = PerformLDF(opcode);
	} else if (LFM_OP(opcode)) {
		nRc = PerformLFM(opcode);
	} else if (STF_OP(opcode)) {
		nRc = PerformSTF(opcode);
	} else if (SFM_OP(opcode)) {
		nRc = PerformSFM(opcode);
	} else {
		nRc = 0;
	}

	return nRc;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	NetWinder Floating Point Emulator
	3	(c) Rebel.com, 1998-1999
	4	(c) Philip Blundell, 1998, 2001
	5
	6	Direct questions, comments to Scott Bambrough <scottb@netwinder.org>
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	21	*/
	22
1da177e4 LT	23	#include "fpa11.h"
	24	#include "softfloat.h"
	25	#include "fpopcode.h"
	26	#include "fpmodule.h"
	27	#include "fpmodule.inl"
	28
33fa9b13	29	#include <linux/uaccess.h>
1da177e4 LT	30
	31	static inline void loadSingle(const unsigned int Fn, const unsigned int __user *pMem)
	32	{
	33	FPA11 *fpa11 = GET_FPA11();
	34	fpa11->fType[Fn] = typeSingle;
	35	get_user(fpa11->fpreg[Fn].fSingle, pMem);
	36	}
	37
	38	static inline void loadDouble(const unsigned int Fn, const unsigned int __user *pMem)
	39	{
	40	FPA11 *fpa11 = GET_FPA11();
	41	unsigned int *p;
	42	p = (unsigned int *) &fpa11->fpreg[Fn].fDouble;
	43	fpa11->fType[Fn] = typeDouble;
	44	#ifdef __ARMEB__
	45	get_user(p[0], &pMem[0]); /* sign & exponent */
	46	get_user(p[1], &pMem[1]);
	47	#else
	48	get_user(p[0], &pMem[1]);
	49	get_user(p[1], &pMem[0]); /* sign & exponent */
	50	#endif
	51	}
	52
	53	#ifdef CONFIG_FPE_NWFPE_XP
	54	static inline void loadExtended(const unsigned int Fn, const unsigned int __user *pMem)
	55	{
	56	FPA11 *fpa11 = GET_FPA11();
	57	unsigned int *p;
	58	p = (unsigned int *) &fpa11->fpreg[Fn].fExtended;
	59	fpa11->fType[Fn] = typeExtended;
	60	get_user(p[0], &pMem[0]); /* sign & exponent */
bedf142b LB	61	#ifdef __ARMEB__
	62	get_user(p[1], &pMem[1]); /* ms bits */
	63	get_user(p[2], &pMem[2]); /* ls bits */
	64	#else
1da177e4 LT	65	get_user(p[1], &pMem[2]); /* ls bits */
1da177e4 LT	66	get_user(p[2], &pMem[1]); /* ms bits */
bedf142b	67	#endif
1da177e4 LT	68	}
	69	#endif
	70
	71	static inline void loadMultiple(const unsigned int Fn, const unsigned int __user *pMem)
	72	{
	73	FPA11 *fpa11 = GET_FPA11();
	74	register unsigned int *p;
	75	unsigned long x;
	76
	77	p = (unsigned int *) &(fpa11->fpreg[Fn]);
	78	get_user(x, &pMem[0]);
	79	fpa11->fType[Fn] = (x >> 14) & 0x00000003;
	80
	81	switch (fpa11->fType[Fn]) {
	82	case typeSingle:
	83	case typeDouble:
	84	{
	85	get_user(p[0], &pMem[2]); /* Single */
	86	get_user(p[1], &pMem[1]); /* double msw */
	87	p[2] = 0; /* empty */
	88	}
	89	break;
	90
	91	#ifdef CONFIG_FPE_NWFPE_XP
	92	case typeExtended:
	93	{
	94	get_user(p[1], &pMem[2]);
	95	get_user(p[2], &pMem[1]); /* msw */
	96	p[0] = (x & 0x80003fff);
	97	}
	98	break;
	99	#endif
	100	}
	101	}
	102
f148af25	103	static inline void storeSingle(struct roundingData roundData, const unsigned int Fn, unsigned int __user pMem)
1da177e4 LT	104	{
	105	FPA11 *fpa11 = GET_FPA11();
	106	union {
	107	float32 f;
	108	unsigned int i[1];
	109	} val;
	110
	111	switch (fpa11->fType[Fn]) {
	112	case typeDouble:
f148af25	113	val.f = float64_to_float32(roundData, fpa11->fpreg[Fn].fDouble);
1da177e4 LT	114	break;
	115
	116	#ifdef CONFIG_FPE_NWFPE_XP
	117	case typeExtended:
f148af25	118	val.f = floatx80_to_float32(roundData, fpa11->fpreg[Fn].fExtended);
1da177e4 LT	119	break;
	120	#endif
	121
	122	default:
	123	val.f = fpa11->fpreg[Fn].fSingle;
	124	}
	125
	126	put_user(val.i[0], pMem);
	127	}
	128
f148af25	129	static inline void storeDouble(struct roundingData roundData, const unsigned int Fn, unsigned int __user pMem)
1da177e4 LT	130	{
	131	FPA11 *fpa11 = GET_FPA11();
	132	union {
	133	float64 f;
	134	unsigned int i[2];
	135	} val;
	136
	137	switch (fpa11->fType[Fn]) {
	138	case typeSingle:
	139	val.f = float32_to_float64(fpa11->fpreg[Fn].fSingle);
	140	break;
	141
	142	#ifdef CONFIG_FPE_NWFPE_XP
	143	case typeExtended:
f148af25	144	val.f = floatx80_to_float64(roundData, fpa11->fpreg[Fn].fExtended);
1da177e4 LT	145	break;
	146	#endif
	147
	148	default:
	149	val.f = fpa11->fpreg[Fn].fDouble;
	150	}
	151
	152	#ifdef __ARMEB__
	153	put_user(val.i[0], &pMem[0]); /* msw */
	154	put_user(val.i[1], &pMem[1]); /* lsw */
	155	#else
	156	put_user(val.i[1], &pMem[0]); /* msw */
	157	put_user(val.i[0], &pMem[1]); /* lsw */
	158	#endif
	159	}
	160
	161	#ifdef CONFIG_FPE_NWFPE_XP
	162	static inline void storeExtended(const unsigned int Fn, unsigned int __user *pMem)
	163	{
	164	FPA11 *fpa11 = GET_FPA11();
	165	union {
	166	floatx80 f;
	167	unsigned int i[3];
	168	} val;
	169
	170	switch (fpa11->fType[Fn]) {
	171	case typeSingle:
	172	val.f = float32_to_floatx80(fpa11->fpreg[Fn].fSingle);
	173	break;
	174
	175	case typeDouble:
	176	val.f = float64_to_floatx80(fpa11->fpreg[Fn].fDouble);
	177	break;
	178
	179	default:
	180	val.f = fpa11->fpreg[Fn].fExtended;
	181	}
	182
	183	put_user(val.i[0], &pMem[0]); /* sign & exp */
bedf142b LB	184	#ifdef __ARMEB__
	185	put_user(val.i[1], &pMem[1]); /* msw */
	186	put_user(val.i[2], &pMem[2]);
	187	#else
1da177e4 LT	188	put_user(val.i[1], &pMem[2]);
1da177e4 LT	189	put_user(val.i[2], &pMem[1]); /* msw */
bedf142b	190	#endif
1da177e4 LT	191	}
	192	#endif
	193
	194	static inline void storeMultiple(const unsigned int Fn, unsigned int __user *pMem)
	195	{
	196	FPA11 *fpa11 = GET_FPA11();
	197	register unsigned int nType, *p;
	198
	199	p = (unsigned int *) &(fpa11->fpreg[Fn]);
	200	nType = fpa11->fType[Fn];
	201
	202	switch (nType) {
	203	case typeSingle:
	204	case typeDouble:
	205	{
	206	put_user(p[0], &pMem[2]); /* single */
	207	put_user(p[1], &pMem[1]); /* double msw */
	208	put_user(nType << 14, &pMem[0]);
	209	}
	210	break;
	211
	212	#ifdef CONFIG_FPE_NWFPE_XP
	213	case typeExtended:
	214	{
	215	put_user(p[2], &pMem[1]); /* msw */
	216	put_user(p[1], &pMem[2]);
	217	put_user((p[0] & 0x80003fff) \| (nType << 14), &pMem[0]);
	218	}
	219	break;
	220	#endif
	221	}
	222	}
	223
	224	unsigned int PerformLDF(const unsigned int opcode)
	225	{
	226	unsigned int __user pBase, pAddress, *pFinal;
	227	unsigned int nRc = 1, write_back = WRITE_BACK(opcode);
	228
	229	pBase = (unsigned int __user *) readRegister(getRn(opcode));
	230	if (REG_PC == getRn(opcode)) {
	231	pBase += 2;
	232	write_back = 0;
	233	}
	234
	235	pFinal = pBase;
	236	if (BIT_UP_SET(opcode))
	237	pFinal += getOffset(opcode);
	238	else
	239	pFinal -= getOffset(opcode);
	240
	241	if (PREINDEXED(opcode))
	242	pAddress = pFinal;
	243	else
	244	pAddress = pBase;
	245
	246	switch (opcode & MASK_TRANSFER_LENGTH) {
	247	case TRANSFER_SINGLE:
	248	loadSingle(getFd(opcode), pAddress);
	249	break;
	250	case TRANSFER_DOUBLE:
	251	loadDouble(getFd(opcode), pAddress);
	252	break;
	253	#ifdef CONFIG_FPE_NWFPE_XP
	254	case TRANSFER_EXTENDED:
255	loadExtended(getFd(opcode), pAddress);
256	break;
257	#endif
258	default:
259	nRc = 0;
260	}
261
262	if (write_back)
263	writeRegister(getRn(opcode), (unsigned long) pFinal);
264	return nRc;
265	}
266
267	unsigned int PerformSTF(const unsigned int opcode)
268	{
269	unsigned int __user pBase, pAddress, *pFinal;
270	unsigned int nRc = 1, write_back = WRITE_BACK(opcode);
f148af25	271	struct roundingData roundData;
1da177e4	272
f148af25 RP	273	roundData.mode = SetRoundingMode(opcode);
	274	roundData.precision = SetRoundingPrecision(opcode);
	275	roundData.exception = 0;
1da177e4 LT	276
	277	pBase = (unsigned int __user *) readRegister(getRn(opcode));
	278	if (REG_PC == getRn(opcode)) {
	279	pBase += 2;
	280	write_back = 0;
	281	}
	282
	283	pFinal = pBase;
	284	if (BIT_UP_SET(opcode))
	285	pFinal += getOffset(opcode);
	286	else
	287	pFinal -= getOffset(opcode);
	288
	289	if (PREINDEXED(opcode))
	290	pAddress = pFinal;
	291	else
	292	pAddress = pBase;
	293
	294	switch (opcode & MASK_TRANSFER_LENGTH) {
	295	case TRANSFER_SINGLE:
f148af25	296	storeSingle(&roundData, getFd(opcode), pAddress);
1da177e4 LT	297	break;
1da177e4 LT	298	case TRANSFER_DOUBLE:
f148af25	299	storeDouble(&roundData, getFd(opcode), pAddress);
1da177e4 LT	300	break;
	301	#ifdef CONFIG_FPE_NWFPE_XP
	302	case TRANSFER_EXTENDED:
	303	storeExtended(getFd(opcode), pAddress);
	304	break;
	305	#endif
	306	default:
	307	nRc = 0;
	308	}
	309
f148af25 RP	310	if (roundData.exception)
	311	float_raise(roundData.exception);
	312
1da177e4 LT	313	if (write_back)
	314	writeRegister(getRn(opcode), (unsigned long) pFinal);
	315	return nRc;
	316	}
	317
	318	unsigned int PerformLFM(const unsigned int opcode)
	319	{
	320	unsigned int __user pBase, pAddress, *pFinal;
	321	unsigned int i, Fd, write_back = WRITE_BACK(opcode);
	322
	323	pBase = (unsigned int __user *) readRegister(getRn(opcode));
	324	if (REG_PC == getRn(opcode)) {
	325	pBase += 2;
	326	write_back = 0;
	327	}
	328
	329	pFinal = pBase;
	330	if (BIT_UP_SET(opcode))
	331	pFinal += getOffset(opcode);
	332	else
	333	pFinal -= getOffset(opcode);
	334
	335	if (PREINDEXED(opcode))
	336	pAddress = pFinal;
	337	else
	338	pAddress = pBase;
	339
	340	Fd = getFd(opcode);
	341	for (i = getRegisterCount(opcode); i > 0; i--) {
	342	loadMultiple(Fd, pAddress);
	343	pAddress += 3;
	344	Fd++;
	345	if (Fd == 8)
	346	Fd = 0;
	347	}
	348
	349	if (write_back)
	350	writeRegister(getRn(opcode), (unsigned long) pFinal);
	351	return 1;
	352	}
	353
	354	unsigned int PerformSFM(const unsigned int opcode)
	355	{
	356	unsigned int __user pBase, pAddress, *pFinal;
	357	unsigned int i, Fd, write_back = WRITE_BACK(opcode);
	358
	359	pBase = (unsigned int __user *) readRegister(getRn(opcode));
	360	if (REG_PC == getRn(opcode)) {
	361	pBase += 2;
	362	write_back = 0;
	363	}
	364
	365	pFinal = pBase;
	366	if (BIT_UP_SET(opcode))
	367	pFinal += getOffset(opcode);
	368	else
	369	pFinal -= getOffset(opcode);
	370
	371	if (PREINDEXED(opcode))
	372	pAddress = pFinal;
	373	else
	374	pAddress = pBase;
	375
	376	Fd = getFd(opcode);
377	for (i = getRegisterCount(opcode); i > 0; i--) {
378	storeMultiple(Fd, pAddress);
379	pAddress += 3;
380	Fd++;
381	if (Fd == 8)
382	Fd = 0;
383	}
384
385	if (write_back)
386	writeRegister(getRn(opcode), (unsigned long) pFinal);
387	return 1;
388	}
389
390	unsigned int EmulateCPDT(const unsigned int opcode)
391	{
392	unsigned int nRc = 0;
393
394	if (LDF_OP(opcode)) {
395	nRc = PerformLDF(opcode);
396	} else if (LFM_OP(opcode)) {
397	nRc = PerformLFM(opcode);
398	} else if (STF_OP(opcode)) {
399	nRc = PerformSTF(opcode);
400	} else if (SFM_OP(opcode)) {
401	nRc = PerformSFM(opcode);
402	} else {
403	nRc = 0;
404	}
405
406	return nRc;
407	}