This source file includes following definitions.
- math_emulate
- valid_prefix
- __math_abort
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 #include <linux/signal.h>
27 #include <linux/segment.h>
28
29 #include "fpu_system.h"
30 #include "fpu_emu.h"
31 #include "exception.h"
32 #include "control_w.h"
33 #include "status_w.h"
34
35 #include <asm/segment.h>
36
37 #define FWAIT_OPCODE 0x9b
38 #define OP_SIZE_PREFIX 0x66
39 #define ADDR_SIZE_PREFIX 0x67
40 #define PREFIX_CS 0x2e
41 #define PREFIX_DS 0x3e
42 #define PREFIX_ES 0x26
43 #define PREFIX_SS 0x36
44 #define PREFIX_FS 0x64
45 #define PREFIX_GS 0x65
46
47 #define __BAD__ Un_impl
48
49 #ifndef NO_UNDOC_CODE
50
51
52
53
54
55
56 #define _d9_d8_ fstp_i
57 #define _dc_d0_ fcom_st
58 #define _dc_d8_ fcompst
59 #define _dd_c8_ fxch_i
60 #define _de_d0_ fcompst
61 #define _df_c0_ ffreep
62 #define _df_c8_ fxch_i
63 #define _df_d0_ fstp_i
64 #define _df_d8_ fstp_i
65
66 static FUNC const st_instr_table[64] = {
67 fadd__, fld_i_, __BAD__, __BAD__, fadd_i, ffree_, faddp_, _df_c0_,
68 fmul__, fxch_i, __BAD__, __BAD__, fmul_i, _dd_c8_, fmulp_, _df_c8_,
69 fcom_st, fp_nop, __BAD__, __BAD__, _dc_d0_, fst_i_, _de_d0_, _df_d0_,
70 fcompst, _d9_d8_, __BAD__, __BAD__, _dc_d8_, fstp_i, fcompp, _df_d8_,
71 fsub__, fp_etc, __BAD__, finit_, fsubri, fucom_, fsubrp, fstsw_,
72 fsubr_, fconst, fucompp, __BAD__, fsub_i, fucomp, fsubp_, __BAD__,
73 fdiv__, trig_a, __BAD__, __BAD__, fdivri, __BAD__, fdivrp, __BAD__,
74 fdivr_, trig_b, __BAD__, __BAD__, fdiv_i, __BAD__, fdivp_, __BAD__,
75 };
76
77 #else
78
79 static FUNC const st_instr_table[64] = {
80 fadd__, fld_i_, __BAD__, __BAD__, fadd_i, ffree_, faddp_, __BAD__,
81 fmul__, fxch_i, __BAD__, __BAD__, fmul_i, __BAD__, fmulp_, __BAD__,
82 fcom_st, fp_nop, __BAD__, __BAD__, __BAD__, fst_i_, __BAD__, __BAD__,
83 fcompst, __BAD__, __BAD__, __BAD__, __BAD__, fstp_i, fcompp, __BAD__,
84 fsub__, fp_etc, __BAD__, finit_, fsubri, fucom_, fsubrp, fstsw_,
85 fsubr_, fconst, fucompp, __BAD__, fsub_i, fucomp, fsubp_, __BAD__,
86 fdiv__, trig_a, __BAD__, __BAD__, fdivri, __BAD__, fdivrp, __BAD__,
87 fdivr_, trig_b, __BAD__, __BAD__, fdiv_i, __BAD__, fdivp_, __BAD__,
88 };
89
90 #endif NO_UNDOC_CODE
91
92
93 #define _NONE_ 0
94 #define _REG0_ 1
95 #define _REGI_ 2
96 #define _REGi_ 0
97 #define _PUSH_ 3
98 #define _null_ 4
99 #define _REGIi 5
100 #define _REGIp 6
101 #define _REGIc 0
102 #define _REGIn 0
103
104 #ifndef NO_UNDOC_CODE
105
106
107
108 static unsigned char const type_table[64] = {
109 _REGI_, _NONE_, _null_, _null_, _REGIi, _REGi_, _REGIp, _REGi_,
110 _REGI_, _REGIn, _null_, _null_, _REGIi, _REGI_, _REGIp, _REGI_,
111 _REGIc, _NONE_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
112 _REGIc, _REG0_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
113 _REGI_, _NONE_, _null_, _NONE_, _REGIi, _REGIc, _REGIp, _NONE_,
114 _REGI_, _NONE_, _REGIc, _null_, _REGIi, _REGIc, _REGIp, _null_,
115 _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
116 _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_
117 };
118
119 #else
120
121 static unsigned char const type_table[64] = {
122 _REGI_, _NONE_, _null_, _null_, _REGIi, _REGi_, _REGIp, _null_,
123 _REGI_, _REGIn, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
124 _REGIc, _NONE_, _null_, _null_, _null_, _REG0_, _null_, _null_,
125 _REGIc, _null_, _null_, _null_, _null_, _REG0_, _REGIc, _null_,
126 _REGI_, _NONE_, _null_, _NONE_, _REGIi, _REGIc, _REGIp, _NONE_,
127 _REGI_, _NONE_, _REGIc, _null_, _REGIi, _REGIc, _REGIp, _null_,
128 _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
129 _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_
130 };
131
132 #endif NO_UNDOC_CODE
133
134
135
136
137 unsigned char FPU_rm;
138 char FPU_st0_tag;
139 FPU_REG *FPU_st0_ptr;
140
141
142 unsigned long FPU_entry_op_cs;
143 unsigned short FPU_data_selector;
144
145
146 #ifdef PARANOID
147 char emulating=0;
148 #endif PARANOID
149
150 #define bswapw(x) __asm__("xchgb %%al,%%ah":"=a" (x):"0" ((short)x))
151 static int valid_prefix(unsigned char byte);
152
153
154 asmlinkage void math_emulate(long arg)
155 {
156 unsigned char FPU_modrm;
157 unsigned short code;
158 int unmasked;
159
160 #ifdef PARANOID
161 if ( emulating )
162 {
163 printk("ERROR: wm-FPU-emu is not RE-ENTRANT!\n");
164 }
165 RE_ENTRANT_CHECK_ON;
166 #endif PARANOID
167
168 if (!current->used_math)
169 {
170 int i;
171 for ( i = 0; i < 8; i++ )
172 {
173
174
175 regs[i].exp = 0;
176 regs[i].sigh = 0x80000000;
177 }
178 finit();
179 current->used_math = 1;
180 }
181
182 SETUP_DATA_AREA(arg);
183
184
185 if (FPU_EFLAGS & 0x00020000)
186 {
187 FPU_ORIG_EIP = FPU_EIP;
188 math_abort(FPU_info,SIGILL);
189 }
190
191
192 if (FPU_CS == KERNEL_CS)
193 {
194 printk("math_emulate: %04x:%08lx\n",FPU_CS,FPU_EIP);
195 panic("Math emulation needed in kernel");
196 }
197
198
199 if (FPU_CS != USER_CS || FPU_DS != USER_DS)
200 {
201 FPU_ORIG_EIP = FPU_EIP;
202 math_abort(FPU_info,SIGILL);
203 }
204
205 FPU_lookahead = 1;
206 if (current->flags & PF_PTRACED)
207 FPU_lookahead = 0;
208
209 do_another_FPU_instruction:
210
211 RE_ENTRANT_CHECK_OFF;
212 code = get_fs_word((unsigned short *) FPU_EIP);
213 RE_ENTRANT_CHECK_ON;
214
215 #ifdef PECULIAR_486
216
217
218
219 FPU_data_selector = FPU_DS;
220 #endif PECULIAR_486
221
222 if ( (code & 0xf8) != 0xd8 )
223 {
224 if ( (code & 0xff) == FWAIT_OPCODE )
225 {
226 if (partial_status & SW_Summary)
227 goto do_the_FPU_interrupt;
228 else
229 {
230 FPU_EIP++;
231 goto FPU_fwait_done;
232 }
233 }
234 else if ( valid_prefix(code & 0xff) )
235 {
236 goto do_another_FPU_instruction;
237 }
238 #ifdef PARANOID
239 RE_ENTRANT_CHECK_OFF;
240 printk("FPU emulator: Unknown prefix byte 0x%02x\n", code & 0xff);
241 RE_ENTRANT_CHECK_ON;
242 EXCEPTION(EX_INTERNAL|0x126);
243 FPU_EIP++;
244 goto do_the_FPU_interrupt;
245 #endif PARANOID
246 }
247
248 if (partial_status & SW_Summary)
249 {
250
251
252
253
254
255
256
257 if ( ! ( (((code & 0xf803) == 0xe003) ||
258 (((code & 0x3003) == 0x3001) &&
259
260 ((code & 0xc000) != 0xc000))) ) )
261 {
262
263
264
265
266
267
268
269
270 do_the_FPU_interrupt:
271 cs_selector &= 0xffff0000;
272 cs_selector |= status_word();
273 operand_selector = tag_word();
274 partial_status = 0;
275 top = 0;
276 {
277 int r;
278 for (r = 0; r < 8; r++)
279 {
280 regs[r].tag = TW_Empty;
281 }
282 }
283
284 RE_ENTRANT_CHECK_OFF;
285 send_sig(SIGFPE, current, 1);
286 return;
287 }
288 }
289
290 FPU_entry_eip = FPU_ORIG_EIP = FPU_EIP;
291
292 {
293 unsigned short swapped_code = code;
294 bswapw(swapped_code);
295 FPU_entry_op_cs = (swapped_code << 16) | (FPU_CS & 0xffff) ;
296 }
297
298 if ( (code & 0xff) == OP_SIZE_PREFIX )
299 {
300 FPU_EIP++;
301 RE_ENTRANT_CHECK_OFF;
302 code = get_fs_word((unsigned short *) FPU_EIP);
303 RE_ENTRANT_CHECK_ON;
304 }
305 FPU_EIP += 2;
306
307 FPU_modrm = code >> 8;
308 FPU_rm = FPU_modrm & 7;
309
310 if ( FPU_modrm < 0300 )
311 {
312
313 get_address(FPU_modrm);
314 if ( !(code & 1) )
315 {
316 unsigned short status1 = partial_status;
317 FPU_st0_ptr = &st(0);
318 FPU_st0_tag = FPU_st0_ptr->tag;
319
320
321 if ( NOT_EMPTY_0 )
322 {
323 unmasked = 0;
324 switch ( (code >> 1) & 3 )
325 {
326 case 0:
327 unmasked = reg_load_single();
328 break;
329 case 1:
330 reg_load_int32();
331 break;
332 case 2:
333 unmasked = reg_load_double();
334 break;
335 case 3:
336 reg_load_int16();
337 break;
338 }
339
340
341
342 FPU_st0_ptr = &st(0);
343 FPU_st0_tag = FPU_st0_ptr->tag;
344
345
346
347
348 if ( (FPU_st0_tag == TW_NaN) ||
349 (FPU_loaded_data.tag == TW_NaN) )
350 {
351
352
353 partial_status = status1;
354 if ( (FPU_modrm & 0x30) == 0x10 )
355 {
356
357 EXCEPTION(EX_Invalid);
358 setcc(SW_C3 | SW_C2 | SW_C0);
359 if ( (FPU_modrm & 0x08) && (control_word & CW_Invalid) )
360 pop();
361 }
362 else
363 {
364 #ifdef PECULIAR_486
365
366
367 if ( (FPU_modrm & 0x28) == 0x20 )
368
369 real_2op_NaN(&FPU_loaded_data, FPU_st0_ptr,
370 FPU_st0_ptr);
371 else
372 #endif PECULIAR_486
373
374 real_2op_NaN(FPU_st0_ptr, &FPU_loaded_data,
375 FPU_st0_ptr);
376 }
377 goto reg_mem_instr_done;
378 }
379
380 if ( unmasked && !((FPU_modrm & 0x30) == 0x10) )
381 {
382
383 if ( (FPU_modrm & 0x38) == 0x38 )
384 {
385
386 if ( (FPU_st0_tag == TW_Zero) &&
387 (FPU_loaded_data.tag == TW_Valid) )
388 {
389 if ( divide_by_zero(FPU_loaded_data.sign,
390 FPU_st0_ptr) )
391 {
392
393
394
395
396 partial_status &= ~SW_Denorm_Op;
397 partial_status |= status1 & SW_Denorm_Op;
398 }
399 }
400 }
401 goto reg_mem_instr_done;
402 }
403
404 switch ( (FPU_modrm >> 3) & 7 )
405 {
406 case 0:
407 clear_C1();
408 reg_add(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr,
409 control_word);
410 break;
411 case 1:
412 clear_C1();
413 reg_mul(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr,
414 control_word);
415 break;
416 case 2:
417 compare_st_data();
418 break;
419 case 3:
420 if ( !compare_st_data() && !unmasked )
421 pop();
422 break;
423 case 4:
424 clear_C1();
425 reg_sub(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr,
426 control_word);
427 break;
428 case 5:
429 clear_C1();
430 reg_sub(&FPU_loaded_data, FPU_st0_ptr, FPU_st0_ptr,
431 control_word);
432 break;
433 case 6:
434 clear_C1();
435 reg_div(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr,
436 control_word);
437 break;
438 case 7:
439 clear_C1();
440 if ( FPU_st0_tag == TW_Zero )
441 partial_status = status1;
442
443 reg_div(&FPU_loaded_data, FPU_st0_ptr, FPU_st0_ptr,
444 control_word);
445 break;
446 }
447 }
448 else
449 {
450 if ( (FPU_modrm & 0x30) == 0x10 )
451 {
452
453 EXCEPTION(EX_StackUnder);
454 setcc(SW_C3 | SW_C2 | SW_C0);
455 if ( (FPU_modrm & 0x08) && (control_word & CW_Invalid) )
456 pop();
457 }
458 else
459 stack_underflow();
460 }
461 }
462 else
463 {
464 load_store_instr(((FPU_modrm & 0x38) | (code & 6)) >> 1);
465 }
466
467 reg_mem_instr_done:
468
469 #ifndef PECULIAR_486
470 *(unsigned short *)&operand_selector = FPU_data_selector;
471 #endif PECULIAR_486
472 ;
473 }
474 else
475 {
476
477 unsigned char instr_index = (FPU_modrm & 0x38) | (code & 7);
478
479 #ifdef PECULIAR_486
480
481
482 FPU_data_address = 0;
483 #endif PECULIAR_486
484
485 FPU_st0_ptr = &st(0);
486 FPU_st0_tag = FPU_st0_ptr->tag;
487 switch ( type_table[(int) instr_index] )
488 {
489 case _NONE_:
490 break;
491 case _REG0_:
492 if ( !NOT_EMPTY_0 )
493 {
494 stack_underflow();
495 goto FPU_instruction_done;
496 }
497 break;
498 case _REGIi:
499 if ( !NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm) )
500 {
501 stack_underflow_i(FPU_rm);
502 goto FPU_instruction_done;
503 }
504 break;
505 case _REGIp:
506 if ( !NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm) )
507 {
508 stack_underflow_pop(FPU_rm);
509 goto FPU_instruction_done;
510 }
511 break;
512 case _REGI_:
513 if ( !NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm) )
514 {
515 stack_underflow();
516 goto FPU_instruction_done;
517 }
518 break;
519 case _PUSH_:
520 break;
521 case _null_:
522 Un_impl();
523 goto FPU_instruction_done;
524 default:
525 EXCEPTION(EX_INTERNAL|0x111);
526 goto FPU_instruction_done;
527 }
528 (*st_instr_table[(int) instr_index])();
529 }
530
531 FPU_instruction_done:
532
533 #ifdef DEBUG
534 {
535 static unsigned int count = 0;
536 if ( (++count % 10000) == 0 )
537 printk("%d FP instr., current=0x%04x\n", count, code);
538 }
539 #endif DEBUG
540
541 ip_offset = FPU_entry_eip;
542 cs_selector = FPU_entry_op_cs;
543 data_operand_offset = (unsigned long)FPU_data_address;
544 #ifdef PECULIAR_486
545 *(unsigned short *)&operand_selector = FPU_data_selector;
546 #endif PECULIAR_486
547
548 FPU_fwait_done:
549
550 #ifdef DEBUG
551 RE_ENTRANT_CHECK_OFF;
552 emu_printall();
553 RE_ENTRANT_CHECK_ON;
554 #endif DEBUG
555
556 if (FPU_lookahead && !need_resched)
557 {
558 unsigned char next;
559
560 RE_ENTRANT_CHECK_OFF;
561 next = get_fs_byte((unsigned char *) FPU_EIP);
562 RE_ENTRANT_CHECK_ON;
563 if ( valid_prefix(next) )
564 goto do_another_FPU_instruction;
565 }
566
567 RE_ENTRANT_CHECK_OFF;
568 }
569
570
571
572
573
574
575 static int valid_prefix(unsigned char byte)
576 {
577 unsigned long ip = FPU_EIP;
578
579 while ( 1 )
580 {
581 switch ( byte )
582 {
583 case ADDR_SIZE_PREFIX:
584 case PREFIX_DS:
585 case PREFIX_CS:
586 case PREFIX_ES:
587 case PREFIX_SS:
588 case PREFIX_FS:
589 case PREFIX_GS:
590
591 case OP_SIZE_PREFIX:
592 RE_ENTRANT_CHECK_OFF;
593 byte = get_fs_byte((unsigned char *) (++FPU_EIP));
594 RE_ENTRANT_CHECK_ON;
595 break;
596 case FWAIT_OPCODE:
597 return 1;
598 default:
599 if ( (byte & 0xf8) == 0xd8 )
600 return 1;
601 else
602 {
603 FPU_EIP = ip;
604 return 0;
605 }
606 }
607 }
608 }
609
610
611 void __math_abort(struct info * info, unsigned int signal)
612 {
613 FPU_EIP = FPU_ORIG_EIP;
614 send_sig(signal,current,1);
615 RE_ENTRANT_CHECK_OFF;
616 __asm__("movl %0,%%esp ; ret": :"g" (((long) info)-4));
617 #ifdef PARANOID
618 printk("ERROR: wm-FPU-emu math_abort failed!\n");
619 #endif PARANOID
620 }