GNU Linux-libre 4.14.266-gnu1
[releases.git] / arch / x86 / math-emu / load_store.c
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                 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(VERIFY_READ, 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(VERIFY_WRITE, 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(VERIFY_WRITE, 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 }