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(stnr: -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(single: (float __user *)data_address, loaded_data: &loaded_data); |
126 | if ((loaded_tag == TAG_Special) |
127 | && isNaN(ptr: &loaded_data) |
128 | && (real_1op_NaN(a: &loaded_data) < 0)) { |
129 | top++; |
130 | break; |
131 | } |
132 | FPU_copy_to_reg0(r: &loaded_data, tag: loaded_tag); |
133 | break; |
134 | case 001: /* fild m32int (db /0) */ |
135 | clear_C1(); |
136 | loaded_tag = |
137 | FPU_load_int32(s: (long __user *)data_address, loaded_data: &loaded_data); |
138 | FPU_copy_to_reg0(r: &loaded_data, tag: loaded_tag); |
139 | break; |
140 | case 002: /* fld m64real (dd /0) */ |
141 | clear_C1(); |
142 | loaded_tag = |
143 | FPU_load_double(dfloat: (double __user *)data_address, |
144 | loaded_data: &loaded_data); |
145 | if ((loaded_tag == TAG_Special) |
146 | && isNaN(ptr: &loaded_data) |
147 | && (real_1op_NaN(a: &loaded_data) < 0)) { |
148 | top++; |
149 | break; |
150 | } |
151 | FPU_copy_to_reg0(r: &loaded_data, tag: loaded_tag); |
152 | break; |
153 | case 003: /* fild m16int (df /0) */ |
154 | clear_C1(); |
155 | loaded_tag = |
156 | FPU_load_int16(s: (short __user *)data_address, loaded_data: &loaded_data); |
157 | FPU_copy_to_reg0(r: &loaded_data, tag: 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, d: (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, d: (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, d: (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 | single: (float __user *)data_address); |
195 | break; |
196 | case 011: /* fist m32int */ |
197 | clear_C1(); |
198 | FPU_store_int32(st0_ptr, st0_tag, d: (long __user *)data_address); |
199 | break; |
200 | case 012: /* fst m64real */ |
201 | clear_C1(); |
202 | FPU_store_double(st0_ptr, st0_tag, |
203 | dfloat: (double __user *)data_address); |
204 | break; |
205 | case 013: /* fist m16int */ |
206 | clear_C1(); |
207 | FPU_store_int16(st0_ptr, st0_tag, d: (short __user *)data_address); |
208 | break; |
209 | case 014: /* fstp m32real */ |
210 | clear_C1(); |
211 | if (FPU_store_single |
212 | (st0_ptr, st0_tag, single: (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, d: (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, dfloat: (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, d: (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, s: (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, data_address: (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(s: (u_char __user *) data_address); |
250 | FPU_settag0(tag: 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(s: (long double __user *)data_address, stnr: 0); |
270 | FPU_settag0(tag: loaded_tag); |
271 | break; |
272 | case 027: /* fild m64int */ |
273 | clear_C1(); |
274 | loaded_tag = FPU_load_int64(s: (long long __user *)data_address); |
275 | if (loaded_tag == TAG_Error) |
276 | return 0; |
277 | FPU_settag0(tag: loaded_tag); |
278 | break; |
279 | case 030: /* fstenv m14/28byte */ |
280 | fstenv(addr_modes, d: (u_char __user *) data_address); |
281 | return 1; |
282 | case 032: /* fsave */ |
283 | fsave(addr_modes, data_address: (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, d: (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, d: (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, d: (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 | |