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