| /*---------------------------------------------------------------------------+ |
| | 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; |
| } |
