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