[deliverable/linux.git] / arch / x86 / math-emu / load_store.c

/*---------------------------------------------------------------------------+
 |  load_store.c                                                             |
 |                                                                           |
 | This file contains most of the code to interpret the FPU instructions     |
 | which load and store from user memory.                                    |
 |                                                                           |
 | Copyright (C) 1992,1993,1994,1997                                         |
 |                       W. Metzenthen, 22 Parker St, Ormond, Vic 3163,      |
 |                       Australia.  E-mail   billm@suburbia.net             |
 |                                                                           |
 |                                                                           |
 +---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------+
 | Note:                                                                     |
 |    The file contains code which accesses user memory.                     |
 |    Emulator static data may change when user memory is accessed, due to   |
 |    other processes using the emulator while swapping is in progress.      |
 +---------------------------------------------------------------------------*/

#include <asm/uaccess.h>

#include "fpu_system.h"
#include "exception.h"
#include "fpu_emu.h"
#include "status_w.h"
#include "control_w.h"

#define _NONE_ 0		/* st0_ptr etc not needed */
#define _REG0_ 1		/* Will be storing st(0) */
#define _PUSH_ 3		/* Need to check for space to push onto stack */
#define _null_ 4		/* Function illegal or not implemented */

#define pop_0()	{ FPU_settag0(TAG_Empty); top++; }

static u_char const type_table[32] = {
	_PUSH_, _PUSH_, _PUSH_, _PUSH_,
	_null_, _null_, _null_, _null_,
	_REG0_, _REG0_, _REG0_, _REG0_,
	_REG0_, _REG0_, _REG0_, _REG0_,
	_NONE_, _null_, _NONE_, _PUSH_,
	_NONE_, _PUSH_, _null_, _PUSH_,
	_NONE_, _null_, _NONE_, _REG0_,
	_NONE_, _REG0_, _NONE_, _REG0_
};

u_char const data_sizes_16[32] = {
	4, 4, 8, 2, 0, 0, 0, 0,
	4, 4, 8, 2, 4, 4, 8, 2,
	14, 0, 94, 10, 2, 10, 0, 8,
	14, 0, 94, 10, 2, 10, 2, 8
};

static u_char const data_sizes_32[32] = {
	4, 4, 8, 2, 0, 0, 0, 0,
	4, 4, 8, 2, 4, 4, 8, 2,
	28, 0, 108, 10, 2, 10, 0, 8,
	28, 0, 108, 10, 2, 10, 2, 8
};

int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
		   void __user * data_address)
{
	FPU_REG loaded_data;
	FPU_REG *st0_ptr;
	u_char st0_tag = TAG_Empty;	/* This is just to stop a gcc warning. */
	u_char loaded_tag;

	st0_ptr = NULL;		/* Initialized just to stop compiler warnings. */

	if (addr_modes.default_mode & PROTECTED) {
		if (addr_modes.default_mode == SEG32) {
			if (access_limit < data_sizes_32[type])
				math_abort(FPU_info, SIGSEGV);
		} else if (addr_modes.default_mode == PM16) {
			if (access_limit < data_sizes_16[type])
				math_abort(FPU_info, SIGSEGV);
		}
#ifdef PARANOID
		else
			EXCEPTION(EX_INTERNAL | 0x140);
#endif /* PARANOID */
	}

	switch (type_table[type]) {
	case _NONE_:
		break;
	case _REG0_:
		st0_ptr = &st(0);	/* Some of these instructions pop after
					   storing */
		st0_tag = FPU_gettag0();
		break;
	case _PUSH_:
		{
			if (FPU_gettagi(-1) != TAG_Empty) {
				FPU_stack_overflow();
				return 0;
			}
			top--;
			st0_ptr = &st(0);
		}
		break;
	case _null_:
		FPU_illegal();
		return 0;
#ifdef PARANOID
	default:
		EXCEPTION(EX_INTERNAL | 0x141);
		return 0;
#endif /* PARANOID */
	}

	switch (type) {
	case 000:		/* fld m32real */
		clear_C1();
		loaded_tag =
		    FPU_load_single((float __user *)data_address, &loaded_data);
		if ((loaded_tag == TAG_Special)
		    && isNaN(&loaded_data)
		    && (real_1op_NaN(&loaded_data) < 0)) {
			top++;
			break;
		}
		FPU_copy_to_reg0(&loaded_data, loaded_tag);
		break;
	case 001:		/* fild m32int */
		clear_C1();
		loaded_tag =
		    FPU_load_int32((long __user *)data_address, &loaded_data);
		FPU_copy_to_reg0(&loaded_data, loaded_tag);
		break;
	case 002:		/* fld m64real */
		clear_C1();
		loaded_tag =
		    FPU_load_double((double __user *)data_address,
				    &loaded_data);
		if ((loaded_tag == TAG_Special)
		    && isNaN(&loaded_data)
		    && (real_1op_NaN(&loaded_data) < 0)) {
			top++;
			break;
		}
		FPU_copy_to_reg0(&loaded_data, loaded_tag);
		break;
	case 003:		/* fild m16int */
		clear_C1();
		loaded_tag =
		    FPU_load_int16((short __user *)data_address, &loaded_data);
		FPU_copy_to_reg0(&loaded_data, loaded_tag);
		break;
	case 010:		/* fst m32real */
		clear_C1();
		FPU_store_single(st0_ptr, st0_tag,
				 (float __user *)data_address);
		break;
	case 011:		/* fist m32int */
		clear_C1();
		FPU_store_int32(st0_ptr, st0_tag, (long __user *)data_address);
		break;
	case 012:		/* fst m64real */
		clear_C1();
		FPU_store_double(st0_ptr, st0_tag,
				 (double __user *)data_address);
		break;
	case 013:		/* fist m16int */
		clear_C1();
		FPU_store_int16(st0_ptr, st0_tag, (short __user *)data_address);
		break;
	case 014:		/* fstp m32real */
		clear_C1();
		if (FPU_store_single
		    (st0_ptr, st0_tag, (float __user *)data_address))
			pop_0();	/* pop only if the number was actually stored
					   (see the 80486 manual p16-28) */
		break;
	case 015:		/* fistp m32int */
		clear_C1();
		if (FPU_store_int32
		    (st0_ptr, st0_tag, (long __user *)data_address))
			pop_0();	/* pop only if the number was actually stored
					   (see the 80486 manual p16-28) */
		break;
	case 016:		/* fstp m64real */
		clear_C1();
		if (FPU_store_double
		    (st0_ptr, st0_tag, (double __user *)data_address))
			pop_0();	/* pop only if the number was actually stored
					   (see the 80486 manual p16-28) */
		break;
	case 017:		/* fistp m16int */
		clear_C1();
		if (FPU_store_int16
		    (st0_ptr, st0_tag, (short __user *)data_address))
			pop_0();	/* pop only if the number was actually stored
					   (see the 80486 manual p16-28) */
		break;
	case 020:		/* fldenv  m14/28byte */
		fldenv(addr_modes, (u_char __user *) data_address);
		/* Ensure that the values just loaded are not changed by
		   fix-up operations. */
		return 1;
	case 022:		/* frstor m94/108byte */
		frstor(addr_modes, (u_char __user *) data_address);
		/* Ensure that the values just loaded are not changed by
		   fix-up operations. */
		return 1;
	case 023:		/* fbld m80dec */
		clear_C1();
		loaded_tag = FPU_load_bcd((u_char __user *) data_address);
		FPU_settag0(loaded_tag);
		break;
	case 024:		/* fldcw */
		RE_ENTRANT_CHECK_OFF;
		FPU_access_ok(VERIFY_READ, data_address, 2);
		FPU_get_user(control_word,
			     (unsigned short __user *)data_address);
		RE_ENTRANT_CHECK_ON;
		if (partial_status & ~control_word & CW_Exceptions)
			partial_status |= (SW_Summary | SW_Backward);
		else
			partial_status &= ~(SW_Summary | SW_Backward);
#ifdef PECULIAR_486
		control_word |= 0x40;	/* An 80486 appears to always set this bit */
#endif /* PECULIAR_486 */
		return 1;
	case 025:		/* fld m80real */
		clear_C1();
		loaded_tag =
		    FPU_load_extended((long double __user *)data_address, 0);
		FPU_settag0(loaded_tag);
		break;
	case 027:		/* fild m64int */
		clear_C1();
		loaded_tag = FPU_load_int64((long long __user *)data_address);
		if (loaded_tag == TAG_Error)
			return 0;
		FPU_settag0(loaded_tag);
		break;
	case 030:		/* fstenv  m14/28byte */
		fstenv(addr_modes, (u_char __user *) data_address);
		return 1;
	case 032:		/* fsave */
		fsave(addr_modes, (u_char __user *) data_address);
		return 1;
	case 033:		/* fbstp m80dec */
		clear_C1();
		if (FPU_store_bcd
		    (st0_ptr, st0_tag, (u_char __user *) data_address))
			pop_0();	/* pop only if the number was actually stored
					   (see the 80486 manual p16-28) */
		break;
	case 034:		/* fstcw m16int */
		RE_ENTRANT_CHECK_OFF;
		FPU_access_ok(VERIFY_WRITE, data_address, 2);
		FPU_put_user(control_word,
			     (unsigned short __user *)data_address);
		RE_ENTRANT_CHECK_ON;
		return 1;
	case 035:		/* fstp m80real */
		clear_C1();
		if (FPU_store_extended
		    (st0_ptr, st0_tag, (long double __user *)data_address))
			pop_0();	/* pop only if the number was actually stored
					   (see the 80486 manual p16-28) */
		break;
	case 036:		/* fstsw m2byte */
		RE_ENTRANT_CHECK_OFF;
		FPU_access_ok(VERIFY_WRITE, data_address, 2);
		FPU_put_user(status_word(),
			     (unsigned short __user *)data_address);
		RE_ENTRANT_CHECK_ON;
		return 1;
	case 037:		/* fistp m64int */
		clear_C1();
		if (FPU_store_int64
		    (st0_ptr, st0_tag, (long long __user *)data_address))
			pop_0();	/* pop only if the number was actually stored
					   (see the 80486 manual p16-28) */
		break;
	}
	return 0;
}
Commit	Line	Data
1da177e4 LT	1	/*---------------------------------------------------------------------------+
	2	\| load_store.c \|
	3	\| \|
	4	\| This file contains most of the code to interpret the FPU instructions \|
	5	\| which load and store from user memory. \|
	6	\| \|
	7	\| Copyright (C) 1992,1993,1994,1997 \|
	8	\| W. Metzenthen, 22 Parker St, Ormond, Vic 3163, \|
	9	\| Australia. E-mail billm@suburbia.net \|
	10	\| \|
	11	\| \|
	12	+---------------------------------------------------------------------------*/
	13
	14	/*---------------------------------------------------------------------------+
	15	\| Note: \|
	16	\| The file contains code which accesses user memory. \|
	17	\| Emulator static data may change when user memory is accessed, due to \|
	18	\| other processes using the emulator while swapping is in progress. \|
	19	+---------------------------------------------------------------------------*/
	20
	21	#include <asm/uaccess.h>
	22
	23	#include "fpu_system.h"
	24	#include "exception.h"
	25	#include "fpu_emu.h"
	26	#include "status_w.h"
	27	#include "control_w.h"
	28
3d0d14f9 IM	29	#define _NONE_ 0 /* st0_ptr etc not needed */
	30	#define _REG0_ 1 /* Will be storing st(0) */
	31	#define _PUSH_ 3 /* Need to check for space to push onto stack */
	32	#define _null_ 4 /* Function illegal or not implemented */
1da177e4 LT	33
	34	#define pop_0() { FPU_settag0(TAG_Empty); top++; }
	35
1da177e4	36	static u_char const type_table[32] = {
3d0d14f9 IM	37	_PUSH_, _PUSH_, _PUSH_, _PUSH_,
	38	_null_, _null_, _null_, _null_,
	39	_REG0_, _REG0_, _REG0_, _REG0_,
	40	_REG0_, _REG0_, _REG0_, _REG0_,
	41	_NONE_, _null_, _NONE_, _PUSH_,
	42	_NONE_, _PUSH_, _null_, _PUSH_,
	43	_NONE_, _null_, _NONE_, _REG0_,
	44	_NONE_, _REG0_, _NONE_, _REG0_
	45	};
1da177e4 LT	46
1da177e4 LT	47	u_char const data_sizes_16[32] = {
3d0d14f9 IM	48	4, 4, 8, 2, 0, 0, 0, 0,
	49	4, 4, 8, 2, 4, 4, 8, 2,
	50	14, 0, 94, 10, 2, 10, 0, 8,
	51	14, 0, 94, 10, 2, 10, 2, 8
1da177e4 LT	52	};
	53
	54	static u_char const data_sizes_32[32] = {
3d0d14f9 IM	55	4, 4, 8, 2, 0, 0, 0, 0,
	56	4, 4, 8, 2, 4, 4, 8, 2,
	57	28, 0, 108, 10, 2, 10, 0, 8,
	58	28, 0, 108, 10, 2, 10, 2, 8
1da177e4 LT	59	};
	60
	61	int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
3d0d14f9	62	void __user * data_address)
1da177e4	63	{
3d0d14f9 IM	64	FPU_REG loaded_data;
	65	FPU_REG *st0_ptr;
	66	u_char st0_tag = TAG_Empty; /* This is just to stop a gcc warning. */
	67	u_char loaded_tag;
1da177e4	68
3d0d14f9	69	st0_ptr = NULL; /* Initialized just to stop compiler warnings. */
1da177e4	70
3d0d14f9 IM	71	if (addr_modes.default_mode & PROTECTED) {
	72	if (addr_modes.default_mode == SEG32) {
	73	if (access_limit < data_sizes_32[type])
	74	math_abort(FPU_info, SIGSEGV);
	75	} else if (addr_modes.default_mode == PM16) {
	76	if (access_limit < data_sizes_16[type])
	77	math_abort(FPU_info, SIGSEGV);
	78	}
1da177e4	79	#ifdef PARANOID
3d0d14f9 IM	80	else
3d0d14f9 IM	81	EXCEPTION(EX_INTERNAL \| 0x140);
1da177e4	82	#endif /* PARANOID */
3d0d14f9	83	}
1da177e4	84
3d0d14f9 IM	85	switch (type_table[type]) {
	86	case _NONE_:
	87	break;
	88	case _REG0_:
	89	st0_ptr = &st(0); /* Some of these instructions pop after
	90	storing */
	91	st0_tag = FPU_gettag0();
	92	break;
	93	case _PUSH_:
	94	{
	95	if (FPU_gettagi(-1) != TAG_Empty) {
	96	FPU_stack_overflow();
	97	return 0;
	98	}
	99	top--;
	100	st0_ptr = &st(0);
	101	}
	102	break;
	103	case _null_:
	104	FPU_illegal();
	105	return 0;
1da177e4	106	#ifdef PARANOID
3d0d14f9 IM	107	default:
	108	EXCEPTION(EX_INTERNAL \| 0x141);
	109	return 0;
1da177e4	110	#endif /* PARANOID */
1da177e4	111	}
3d0d14f9 IM	112
	113	switch (type) {
	114	case 000: /* fld m32real */
	115	clear_C1();
	116	loaded_tag =
	117	FPU_load_single((float __user *)data_address, &loaded_data);
	118	if ((loaded_tag == TAG_Special)
	119	&& isNaN(&loaded_data)
	120	&& (real_1op_NaN(&loaded_data) < 0)) {
	121	top++;
	122	break;
	123	}
	124	FPU_copy_to_reg0(&loaded_data, loaded_tag);
	125	break;
	126	case 001: /* fild m32int */
	127	clear_C1();
	128	loaded_tag =
	129	FPU_load_int32((long __user *)data_address, &loaded_data);
	130	FPU_copy_to_reg0(&loaded_data, loaded_tag);
	131	break;
	132	case 002: /* fld m64real */
	133	clear_C1();
	134	loaded_tag =
	135	FPU_load_double((double __user *)data_address,
	136	&loaded_data);
	137	if ((loaded_tag == TAG_Special)
	138	&& isNaN(&loaded_data)
	139	&& (real_1op_NaN(&loaded_data) < 0)) {
	140	top++;
	141	break;
	142	}
	143	FPU_copy_to_reg0(&loaded_data, loaded_tag);
	144	break;
	145	case 003: /* fild m16int */
	146	clear_C1();
	147	loaded_tag =
	148	FPU_load_int16((short __user *)data_address, &loaded_data);
	149	FPU_copy_to_reg0(&loaded_data, loaded_tag);
	150	break;
	151	case 010: /* fst m32real */
	152	clear_C1();
	153	FPU_store_single(st0_ptr, st0_tag,
	154	(float __user *)data_address);
	155	break;
	156	case 011: /* fist m32int */
	157	clear_C1();
	158	FPU_store_int32(st0_ptr, st0_tag, (long __user *)data_address);
	159	break;
	160	case 012: /* fst m64real */
	161	clear_C1();
	162	FPU_store_double(st0_ptr, st0_tag,
	163	(double __user *)data_address);
	164	break;
	165	case 013: /* fist m16int */
	166	clear_C1();
	167	FPU_store_int16(st0_ptr, st0_tag, (short __user *)data_address);
	168	break;
	169	case 014: /* fstp m32real */
	170	clear_C1();
	171	if (FPU_store_single
	172	(st0_ptr, st0_tag, (float __user *)data_address))
	173	pop_0(); /* pop only if the number was actually stored
	174	(see the 80486 manual p16-28) */
	175	break;
176	case 015: /* fistp m32int */
177	clear_C1();
178	if (FPU_store_int32
179	(st0_ptr, st0_tag, (long __user *)data_address))
180	pop_0(); /* pop only if the number was actually stored
181	(see the 80486 manual p16-28) */
182	break;
183	case 016: /* fstp m64real */
184	clear_C1();
185	if (FPU_store_double
186	(st0_ptr, st0_tag, (double __user *)data_address))
187	pop_0(); /* pop only if the number was actually stored
188	(see the 80486 manual p16-28) */
189	break;
190	case 017: /* fistp m16int */
191	clear_C1();
192	if (FPU_store_int16
193	(st0_ptr, st0_tag, (short __user *)data_address))
194	pop_0(); /* pop only if the number was actually stored
195	(see the 80486 manual p16-28) */
196	break;
197	case 020: /* fldenv m14/28byte */
198	fldenv(addr_modes, (u_char __user *) data_address);
199	/* Ensure that the values just loaded are not changed by
200	fix-up operations. */
201	return 1;
202	case 022: /* frstor m94/108byte */
203	frstor(addr_modes, (u_char __user *) data_address);
204	/* Ensure that the values just loaded are not changed by
205	fix-up operations. */
206	return 1;
207	case 023: /* fbld m80dec */
208	clear_C1();
209	loaded_tag = FPU_load_bcd((u_char __user *) data_address);
210	FPU_settag0(loaded_tag);
211	break;
212	case 024: /* fldcw */
213	RE_ENTRANT_CHECK_OFF;
214	FPU_access_ok(VERIFY_READ, data_address, 2);
215	FPU_get_user(control_word,
216	(unsigned short __user *)data_address);
217	RE_ENTRANT_CHECK_ON;
218	if (partial_status & ~control_word & CW_Exceptions)
219	partial_status \|= (SW_Summary \| SW_Backward);
220	else
221	partial_status &= ~(SW_Summary \| SW_Backward);
1da177e4	222	#ifdef PECULIAR_486
3d0d14f9	223	control_word \|= 0x40; /* An 80486 appears to always set this bit */
1da177e4	224	#endif /* PECULIAR_486 */
3d0d14f9 IM	225	return 1;
	226	case 025: /* fld m80real */
	227	clear_C1();
	228	loaded_tag =
	229	FPU_load_extended((long double __user *)data_address, 0);
	230	FPU_settag0(loaded_tag);
	231	break;
	232	case 027: /* fild m64int */
	233	clear_C1();
	234	loaded_tag = FPU_load_int64((long long __user *)data_address);
	235	if (loaded_tag == TAG_Error)
	236	return 0;
	237	FPU_settag0(loaded_tag);
	238	break;
	239	case 030: /* fstenv m14/28byte */
	240	fstenv(addr_modes, (u_char __user *) data_address);
	241	return 1;
	242	case 032: /* fsave */
	243	fsave(addr_modes, (u_char __user *) data_address);
	244	return 1;
	245	case 033: /* fbstp m80dec */
	246	clear_C1();
	247	if (FPU_store_bcd
	248	(st0_ptr, st0_tag, (u_char __user *) data_address))
	249	pop_0(); /* pop only if the number was actually stored
	250	(see the 80486 manual p16-28) */
	251	break;
	252	case 034: /* fstcw m16int */
	253	RE_ENTRANT_CHECK_OFF;
	254	FPU_access_ok(VERIFY_WRITE, data_address, 2);
	255	FPU_put_user(control_word,
	256	(unsigned short __user *)data_address);
	257	RE_ENTRANT_CHECK_ON;
	258	return 1;
	259	case 035: /* fstp m80real */
	260	clear_C1();
	261	if (FPU_store_extended
	262	(st0_ptr, st0_tag, (long double __user *)data_address))
	263	pop_0(); /* pop only if the number was actually stored
	264	(see the 80486 manual p16-28) */
	265	break;
	266	case 036: /* fstsw m2byte */
	267	RE_ENTRANT_CHECK_OFF;
	268	FPU_access_ok(VERIFY_WRITE, data_address, 2);
	269	FPU_put_user(status_word(),
	270	(unsigned short __user *)data_address);
	271	RE_ENTRANT_CHECK_ON;
	272	return 1;
	273	case 037: /* fistp m64int */
	274	clear_C1();
	275	if (FPU_store_int64
	276	(st0_ptr, st0_tag, (long long __user *)data_address))
	277	pop_0(); /* pop only if the number was actually stored
	278	(see the 80486 manual p16-28) */
	279	break;
	280	}
d606f88f	281	return 0;
1da177e4	282	}