4 * The entry function for wm-FPU-emu
7 * Copyright (C) 1992,1993,1994
8 * W. Metzenthen, 22 Parker St, Ormond, Vic 3163,
9 * Australia. E-mail billm@vaxc.cc.monash.edu.au
10 * All rights reserved.
12 * This copyright notice covers the redistribution and use of the
13 * FPU emulator developed by W. Metzenthen. It covers only its use
14 * in the 386BSD, FreeBSD and NetBSD operating systems. Any other
15 * use is not permitted under this copyright.
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions
20 * 1. Redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer.
22 * 2. Redistributions in binary form must include information specifying
23 * that source code for the emulator is freely available and include
25 * a) an offer to provide the source code for a nominal distribution
27 * b) list at least two alternative methods whereby the source
28 * can be obtained, e.g. a publically accessible bulletin board
29 * and an anonymous ftp site from which the software can be
31 * 3. All advertising materials specifically mentioning features or use of
32 * this emulator must acknowledge that it was developed by W. Metzenthen.
33 * 4. The name of W. Metzenthen may not be used to endorse or promote
34 * products derived from this software without specific prior written
37 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
38 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
39 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
40 * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
41 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
42 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
43 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
44 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
45 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
46 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
49 * The purpose of this copyright, based upon the Berkeley copyright, is to
50 * ensure that the covered software remains freely available to everyone.
52 * The software (with necessary differences) is also available, but under
53 * the terms of the GNU copyleft, for the Linux operating system and for
54 * the djgpp ms-dos extender.
56 * W. Metzenthen June 1994.
58 * $FreeBSD: src/sys/gnu/i386/fpemul/fpu_entry.c,v 1.23 1999/10/12 02:23:14 msmith Exp $
62 /*---------------------------------------------------------------------------+
64 | The file contains code which accesses user memory. |
65 | Emulator static data may change when user memory is accessed, due to |
66 | other processes using the emulator while swapping is in progress. |
67 +---------------------------------------------------------------------------*/
69 /*---------------------------------------------------------------------------+
70 | math_emulate() is the sole entry point for wm-FPU-emu |
71 +---------------------------------------------------------------------------*/
74 #include <sys/param.h>
75 #include <sys/systm.h>
77 #include <sys/kernel.h>
79 #include <machine/cpu.h>
80 #include <machine/pcb.h>
82 #include <gnu/i386/fpemul/fpu_emu.h>
83 #include <gnu/i386/fpemul/fpu_system.h>
84 #include <gnu/i386/fpemul/exception.h>
85 #include <gnu/i386/fpemul/status_w.h>
88 #define __BAD__ Un_impl /* Not implemented */
90 #define FPU_LOOKAHEAD 1 /* For performance boost */
92 #if FPU_LOOKAHEAD != 0 /* I think thet we have to limit the */
93 #define LOOKAHEAD_LIMIT 7 /* Max number of lookahead instructions*/
94 #endif /* Or else a prog consisting of a million */
95 /* fnops will spend all its time in kernel*/
97 #ifndef NO_UNDOC_CODE /* Un-documented FPU op-codes supported by
100 /* WARNING: These codes are not documented by Intel in their 80486 manual
101 and may not work on FPU clones or later Intel FPUs. */
103 /* Changes to support the un-doc codes provided by Linus Torvalds. */
105 #define _d9_d8_ fstp_i /* unofficial code (19) */
106 #define _dc_d0_ fcom_st /* unofficial code (14) */
107 #define _dc_d8_ fcompst /* unofficial code (1c) */
108 #define _dd_c8_ fxch_i /* unofficial code (0d) */
109 #define _de_d0_ fcompst /* unofficial code (16) */
110 #define _df_c0_ ffreep /* unofficial code (07) ffree + pop */
111 #define _df_c8_ fxch_i /* unofficial code (0f) */
112 #define _df_d0_ fstp_i /* unofficial code (17) */
113 #define _df_d8_ fstp_i /* unofficial code (1f) */
115 static FUNC st_instr_table[64] = {
116 fadd__, fld_i_, __BAD__, __BAD__, fadd_i, ffree_, faddp_, _df_c0_,
117 fmul__, fxch_i, __BAD__, __BAD__, fmul_i, _dd_c8_, fmulp_, _df_c8_,
118 fcom_st, fp_nop, __BAD__, __BAD__, _dc_d0_, fst_i_, _de_d0_, _df_d0_,
119 fcompst, _d9_d8_, __BAD__, __BAD__, _dc_d8_, fstp_i, fcompp, _df_d8_,
120 fsub__, fp_etc, __BAD__, finit_, fsubri, fucom_, fsubrp, fstsw_,
121 fsubr_, fconst, fucompp, __BAD__, fsub_i, fucomp, fsubp_, __BAD__,
122 fdiv__, trig_a, __BAD__, __BAD__, fdivri, __BAD__, fdivrp, __BAD__,
123 fdivr_, trig_b, __BAD__, __BAD__, fdiv_i, __BAD__, fdivp_, __BAD__,
125 #else /* Support only documented FPU op-codes */
127 static FUNC st_instr_table[64] = {
128 fadd__, fld_i_, __BAD__, __BAD__, fadd_i, ffree_, faddp_, __BAD__,
129 fmul__, fxch_i, __BAD__, __BAD__, fmul_i, __BAD__, fmulp_, __BAD__,
130 fcom_st, fp_nop, __BAD__, __BAD__, __BAD__, fst_i_, __BAD__, __BAD__,
131 fcompst, __BAD__, __BAD__, __BAD__, __BAD__, fstp_i, fcompp, __BAD__,
132 fsub__, fp_etc, __BAD__, finit_, fsubri, fucom_, fsubrp, fstsw_,
133 fsubr_, fconst, fucompp, __BAD__, fsub_i, fucomp, fsubp_, __BAD__,
134 fdiv__, trig_a, __BAD__, __BAD__, fdivri, __BAD__, fdivrp, __BAD__,
135 fdivr_, trig_b, __BAD__, __BAD__, fdiv_i, __BAD__, fdivp_, __BAD__,
137 #endif /* NO_UNDOC_CODE */
140 #define _NONE_ 0 /* Take no special action */
141 #define _REG0_ 1 /* Need to check for not empty st(0) */
142 #define _REGI_ 2 /* Need to check for not empty st(0) and
144 #define _REGi_ 0 /* Uses st(rm) */
145 #define _PUSH_ 3 /* Need to check for space to push onto stack */
146 #define _null_ 4 /* Function illegal or not implemented */
147 #define _REGIi 5 /* Uses st(0) and st(rm), result to st(rm) */
148 #define _REGIp 6 /* Uses st(0) and st(rm), result to st(rm)
150 #define _REGIc 0 /* Compare st(0) and st(rm) */
151 #define _REGIn 0 /* Uses st(0) and st(rm), but handle checks
154 #ifndef NO_UNDOC_CODE
156 /* Un-documented FPU op-codes supported by default. (see above) */
158 static unsigned char type_table[64] = {
159 _REGI_, _NONE_, _null_, _null_, _REGIi, _REGi_, _REGIp, _REGi_,
160 _REGI_, _REGIn, _null_, _null_, _REGIi, _REGI_, _REGIp, _REGI_,
161 _REGIc, _NONE_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
162 _REGIc, _REG0_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
163 _REGI_, _NONE_, _null_, _NONE_, _REGIi, _REGIc, _REGIp, _NONE_,
164 _REGI_, _NONE_, _REGIc, _null_, _REGIi, _REGIc, _REGIp, _null_,
165 _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
166 _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_
168 #else /* Support only documented FPU op-codes */
170 static unsigned char type_table[64] = {
171 _REGI_, _NONE_, _null_, _null_, _REGIi, _REGi_, _REGIp, _null_,
172 _REGI_, _REGIn, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
173 _REGIc, _NONE_, _null_, _null_, _null_, _REG0_, _null_, _null_,
174 _REGIc, _null_, _null_, _null_, _null_, _REG0_, _REGIc, _null_,
175 _REGI_, _NONE_, _null_, _NONE_, _REGIi, _REGIc, _REGIp, _NONE_,
176 _REGI_, _NONE_, _REGIc, _null_, _REGIi, _REGIc, _REGIp, _null_,
177 _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
178 _REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_
180 #endif /* NO_UNDOC_CODE */
182 /* Be careful when using any of these global variables...
183 they might change if swapping is triggered */
184 unsigned char FPU_rm;
186 FPU_REG *FPU_st0_ptr;
190 #endif /* PARANOID */
192 #define bswapw(x) __asm__("xchgb %%al,%%ah":"=a" (x):"0" ((short)x))
193 #define math_abort(signo) \
194 FPU_EIP = FPU_ORIG_EIP;REENTRANT_CHECK(OFF);return(signo);
197 math_emulate(struct trapframe * tframe)
200 unsigned char FPU_modrm;
202 #ifdef LOOKAHEAD_LIMIT
203 int lookahead_limit = LOOKAHEAD_LIMIT;
207 printf("ERROR: wm-FPU-emu is not RE-ENTRANT!\n");
210 #endif /* PARANOID */
212 if ((((struct pcb *) curproc->p_addr)->pcb_flags & FP_SOFTFP) == 0) {
214 control_word = __INITIAL_NPXCW__;
215 ((struct pcb *) curproc->p_addr)->pcb_flags |= FP_SOFTFP;
218 FPU_ORIG_EIP = FPU_EIP; /* --pink-- */
220 if (FPU_CS != 0x001f) {
221 printf("math_emulate: %x : %x\n", FPU_CS, FPU_EIP);
222 panic("FPU emulation in kernel");
225 /* We cannot handle emulation in v86-mode */
226 if (FPU_EFLAGS & 0x00020000) {
227 FPU_ORIG_EIP = FPU_EIP;
228 math_abort(FPU_info, SIGILL);
232 FPU_lookahead = FPU_LOOKAHEAD;
233 if (curproc->p_flag & P_TRACED)
236 do_another_FPU_instruction:
238 REENTRANT_CHECK(OFF);
239 code = fuword((u_int *) FPU_EIP);
241 if ((code & 0xff) == 0x9b) { /* fwait */
242 if (status_word & SW_Summary)
243 goto do_the_FPU_interrupt;
246 goto FPU_instruction_done;
249 if (status_word & SW_Summary) {
250 /* Ignore the error for now if the current instruction is a
251 * no-wait control instruction */
252 /* The 80486 manual contradicts itself on this topic, so I use
253 * the following list of such instructions until I can check
254 * on a real 80486: fninit, fnstenv, fnsave, fnstsw, fnstenv,
256 if (!((((code & 0xf803) == 0xe003) || /* fnclex, fninit,
258 (((code & 0x3003) == 0x3001) && /* fnsave, fnstcw,
260 ((code & 0xc000) != 0xc000))))) {
261 /* This is a guess about what a real FPU might do to
263 /* status_word &= ~SW_Summary; ****/
265 /* We need to simulate the action of the kernel to FPU
266 * interrupts here. Currently, the "real FPU" part of
267 * the kernel (0.99.10) clears the exception flags,
268 * sets the registers to empty, and passes information
269 * back to the interrupted process via the cs selector
270 * and operand selector, so we do the same. */
271 do_the_FPU_interrupt:
272 cs_selector &= 0xffff0000;
273 cs_selector |= (status_word & ~SW_Top) | ((top & 7) << SW_Top_Shift);
274 operand_selector = tag_word();
279 for (r = 0; r < 8; r++) {
280 regs[r].tag = TW_Empty;
283 REENTRANT_CHECK(OFF);
287 FPU_entry_eip = FPU_ORIG_EIP = FPU_EIP;
289 if ((code & 0xff) == 0x66) { /* size prefix */
291 REENTRANT_CHECK(OFF);
292 code = fuword((u_int *) FPU_EIP);
297 FPU_modrm = code >> 8;
298 FPU_rm = FPU_modrm & 7;
300 if (FPU_modrm < 0300) {
301 /* All of these instructions use the mod/rm byte to get a data
303 get_address(FPU_modrm);
305 unsigned short status1 = status_word;
306 FPU_st0_ptr = &st(0);
307 FPU_st0_tag = FPU_st0_ptr->tag;
309 /* Stack underflow has priority */
311 switch ((code >> 1) & 3) {
326 /* No more access to user memory, it is safe
327 * to use static data now */
328 FPU_st0_ptr = &st(0);
329 FPU_st0_tag = FPU_st0_ptr->tag;
331 /* NaN operands have the next priority. */
332 /* We have to delay looking at st(0) until
333 * after loading the data, because that data
334 * might contain an SNaN */
335 if ((FPU_st0_tag == TW_NaN) ||
336 (FPU_loaded_data.tag == TW_NaN)) {
337 /* Restore the status word; we might
338 * have loaded a denormal. */
339 status_word = status1;
340 if ((FPU_modrm & 0x30) == 0x10) {
342 EXCEPTION(EX_Invalid);
343 setcc(SW_C3 | SW_C2 | SW_C0);
344 if (FPU_modrm & 0x08)
345 pop(); /* fcomp, so we pop. */
347 real_2op_NaN(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr);
348 goto reg_mem_instr_done;
350 switch ((FPU_modrm >> 3) & 7) {
352 reg_add(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
355 reg_mul(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
365 reg_sub(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
368 reg_sub(&FPU_loaded_data, FPU_st0_ptr, FPU_st0_ptr, control_word);
371 reg_div(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
374 if (FPU_st0_tag == TW_Zero)
375 status_word = status1; /* Undo any denorm tag,
378 reg_div(&FPU_loaded_data, FPU_st0_ptr, FPU_st0_ptr, control_word);
382 if ((FPU_modrm & 0x30) == 0x10) {
383 /* The instruction is fcom or fcomp */
384 EXCEPTION(EX_StackUnder);
385 setcc(SW_C3 | SW_C2 | SW_C0);
386 if (FPU_modrm & 0x08)
387 pop(); /* fcomp, Empty or not,
393 load_store_instr(((FPU_modrm & 0x38) | (code & 6)) >> 1);
398 data_operand_offset = (intptr_t) (void *) FPU_data_address;
400 /* None of these instructions access user memory */
401 unsigned char instr_index = (FPU_modrm & 0x38) | (code & 7);
403 FPU_st0_ptr = &st(0);
404 FPU_st0_tag = FPU_st0_ptr->tag;
405 switch (type_table[(int) instr_index]) {
406 case _NONE_: /* also _REGIc: _REGIn */
411 goto FPU_instruction_done;
415 if (!NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm)) {
416 stack_underflow_i(FPU_rm);
417 goto FPU_instruction_done;
421 if (!NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm)) {
422 stack_underflow_i(FPU_rm);
424 goto FPU_instruction_done;
428 if (!NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm)) {
430 goto FPU_instruction_done;
433 case _PUSH_: /* Only used by the fld st(i) instruction */
437 goto FPU_instruction_done;
439 EXCEPTION(EX_INTERNAL | 0x111);
440 goto FPU_instruction_done;
442 (*st_instr_table[(int) instr_index]) ();
445 FPU_instruction_done:
447 ip_offset = FPU_entry_eip;
449 *(1 + (unsigned short *) &cs_selector) = code & 0x7ff;
452 REENTRANT_CHECK(OFF);
456 #ifdef LOOKAHEAD_LIMIT
457 if (--lookahead_limit)
462 /* (This test should generate no machine code) */
464 REENTRANT_CHECK(OFF);
465 next = fubyte((u_char *) FPU_EIP);
467 if (((next & 0xf8) == 0xd8) || (next == 0x9b)) { /* fwait */
468 goto do_another_FPU_instruction;
470 if (next == 0x66) { /* size prefix */
471 REENTRANT_CHECK(OFF);
472 next = fubyte((u_char *) (FPU_EIP + 1));
474 if ((next & 0xf8) == 0xd8) {
476 goto do_another_FPU_instruction;
482 REENTRANT_CHECK(OFF);
483 return (0); /* --pink-- */
487 gnufpu_modevent(module_t mod, int type, void *unused)
492 printf("Another Math emulator already present\n");
495 pmath_emulate = math_emulate;
497 printf("GPL Math emulator present\n");
500 if (pmath_emulate != math_emulate) {
501 printf("Cannot unload another math emulator\n");
506 printf("GPL Math emulator unloaded\n");
514 static moduledata_t gnufpumod = {
519 DECLARE_MODULE(gnufpu, gnufpumod, SI_SUB_DRIVERS, SI_ORDER_ANY);