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 }
283
|
This page was automatically generated by the
LXR engine.
|