arch/x86/math-emu/load_store.c

   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
  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 */
  33
  34 #define pop_0() { FPU_settag0(TAG_Empty); top++; }
  35
  36 static u_char const type_table[32] = {
  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 };
  46
  47 u_char const data_sizes_16[32] = {
  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
  52 };
  53
  54 static u_char const data_sizes_32[32] = {
  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
  59 };
  60
  61 int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
  62                    void __user * data_address)
  63 {
  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;
  68
  69         st0_ptr = NULL;         /* Initialized just to stop compiler warnings. */
  70
  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                 }
  79 #ifdef PARANOID
  80                 else
  81                         EXCEPTION(EX_INTERNAL | 0x140);
  82 #endif /* PARANOID */
  83         }
  84
  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;
 106 #ifdef PARANOID
 107         default:
 108                 EXCEPTION(EX_INTERNAL | 0x141);
 109                 return 0;
 110 #endif /* PARANOID */
 111         }
 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);
 222 #ifdef PECULIAR_486
 223                 control_word |= 0x40;   /* An 80486 appears to always set this bit */
 224 #endif /* PECULIAR_486 */
 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         }
 281         return 0;
 282 }